diff --git a/.gitignore b/.gitignore index d56c01dbdd..dbcf687197 100644 --- a/.gitignore +++ b/.gitignore @@ -29,3 +29,5 @@ _templates API_CC dp/ build_lammps/ +build_tests/ +build_cc_tests \ No newline at end of file diff --git a/deepmd/.gitignore b/deepmd/.gitignore new file mode 100644 index 0000000000..8db60db5b8 --- /dev/null +++ b/deepmd/.gitignore @@ -0,0 +1,3 @@ +op/_*.py +pkg_config +!op/__init__.py \ No newline at end of file diff --git a/deepmd/entrypoints/freeze.py b/deepmd/entrypoints/freeze.py index b7ed983cd0..a6206abef4 100755 --- a/deepmd/entrypoints/freeze.py +++ b/deepmd/entrypoints/freeze.py @@ -66,6 +66,10 @@ def _make_node_names(model_type: str, modifier_type: Optional[str] = None) -> Li elif model_type == "dipole": nodes += [ "o_dipole", + "o_global_dipole", + "o_force", + "o_virial", + "o_atom_virial", "o_rmat", "o_rmat_deriv", "o_nlist", @@ -78,6 +82,10 @@ def _make_node_names(model_type: str, modifier_type: Optional[str] = None) -> Li elif model_type == "polar": nodes += [ "o_polar", + "o_global_polar", + "o_force", + "o_virial", + "o_atom_virial", "model_attr/sel_type", "model_attr/output_dim", ] diff --git a/deepmd/infer/deep_eval.py b/deepmd/infer/deep_eval.py index 20d4f8dd7b..ab00caa5ee 100644 --- a/deepmd/infer/deep_eval.py +++ b/deepmd/infer/deep_eval.py @@ -215,8 +215,9 @@ def reverse_map(vec : np.ndarray, imap : List[int]) -> np.ndarray: Reverse mapped vector. """ ret = np.zeros(vec.shape) - for idx,ii in enumerate(imap) : - ret[:,ii,:] = vec[:,idx,:] + # for idx,ii in enumerate(imap) : + # ret[:,ii,:] = vec[:,idx,:] + ret[:, imap, :] = vec return ret diff --git a/deepmd/infer/deep_polar.py b/deepmd/infer/deep_polar.py index 7ee02cf1c8..42754a3850 100644 --- a/deepmd/infer/deep_polar.py +++ b/deepmd/infer/deep_polar.py @@ -94,7 +94,7 @@ def eval( coords: np.array, cells: np.array, atom_types: List[int], - atomic: bool = True, + atomic: bool = False, fparam: Optional[np.array] = None, aparam: Optional[np.array] = None, efield: Optional[np.array] = None, @@ -114,7 +114,7 @@ def eval( The atom types The list should contain natoms ints atomic - Calculate the atomic energy and virial + Not used in this model fparam Not used in this model aparam diff --git a/deepmd/infer/deep_tensor.py b/deepmd/infer/deep_tensor.py index 1a8b62d855..7ebac1510e 100644 --- a/deepmd/infer/deep_tensor.py +++ b/deepmd/infer/deep_tensor.py @@ -1,5 +1,5 @@ import os -from typing import List, Optional, TYPE_CHECKING +from typing import List, Optional, TYPE_CHECKING, Tuple import numpy as np from deepmd.common import make_default_mesh @@ -53,10 +53,34 @@ def __init__( load_prefix=load_prefix, default_tf_graph=default_tf_graph ) + # check model type + model_type = self.tensors["t_tensor"][2:-2] + assert self.model_type == model_type, \ + f"expect {model_type} model but got {self.model_type}" + # now load tensors to object attributes for attr_name, tensor_name in self.tensors.items(): self._get_tensor(tensor_name, attr_name) - + + # load optional tensors if possible + optional_tensors = { + "t_global_tensor": f"o_global_{model_type}:0", + "t_force": "o_force:0", + "t_virial": "o_virial:0", + "t_atom_virial": "o_atom_virial:0" + } + try: + # first make sure these tensor all exists (but do not modify self attr) + for attr_name, tensor_name in optional_tensors.items(): + self._get_tensor(tensor_name) + # then put those into self.attrs + for attr_name, tensor_name in optional_tensors.items(): + self._get_tensor(tensor_name, attr_name) + self.tensors.update(optional_tensors) + self._support_gfv = True + except KeyError: + self._support_gfv = False + # start a tf session associated to the graph self.sess = tf.Session(graph=self.graph, config=default_tf_session_config) self._run_default_sess() @@ -117,7 +141,8 @@ def eval( The atom types The list should contain natoms ints atomic - Calculate the atomic energy and virial + If True (default), return the atomic tensor + Otherwise return the global tensor fparam Not used in this model aparam @@ -133,15 +158,16 @@ def eval( else of size nframes x natoms x output_dim """ # standarize the shape of inputs - coords = np.array(coords) - cells = np.array(cells) - atom_types = np.array(atom_types, dtype = int) - - # reshape the inputs - cells = np.reshape(cells, [-1, 9]) - nframes = cells.shape[0] - coords = np.reshape(coords, [nframes, -1]) - natoms = coords.shape[1] // 3 + atom_types = np.array(atom_types, dtype = int).reshape([-1]) + natoms = atom_types.size + coords = np.reshape(np.array(coords), [-1, natoms * 3]) + nframes = coords.shape[0] + if cells is None: + pbc = False + cells = np.tile(np.eye(3), [nframes, 1]).reshape([nframes, 9]) + else: + pbc = True + cells = np.array(cells).reshape([nframes, 9]) # sort inputs coords, atom_types, imap, sel_at, sel_imap = self.sort_input(coords, atom_types, sel_atoms = self.get_sel_type()) @@ -151,14 +177,24 @@ def eval( assert(natoms_vec[0] == natoms) # evaluate - tensor = [] feed_dict_test = {} feed_dict_test[self.t_natoms] = natoms_vec feed_dict_test[self.t_type ] = np.tile(atom_types, [nframes,1]).reshape([-1]) - t_out = [self.t_tensor] feed_dict_test[self.t_coord] = np.reshape(coords, [-1]) feed_dict_test[self.t_box ] = np.reshape(cells , [-1]) - feed_dict_test[self.t_mesh ] = make_default_mesh(cells) + if pbc: + feed_dict_test[self.t_mesh ] = make_default_mesh(cells) + else: + feed_dict_test[self.t_mesh ] = np.array([], dtype = np.int32) + + if atomic: + assert "global" not in self.model_type, \ + f"cannot do atomic evaluation with model type {self.model_type}" + t_out = [self.t_tensor] + else: + assert self._support_gfv or "global" in self.model_type, \ + f"do not support global tensor evaluation with old {self.model_type} model" + t_out = [self.t_global_tensor if self._support_gfv else self.t_tensor] v_out = self.sess.run (t_out, feed_dict = feed_dict_test) tensor = v_out[0] @@ -171,3 +207,122 @@ def eval( tensor = np.reshape(tensor, [nframes, self.output_dim]) return tensor + + def eval_full( + self, + coords: np.array, + cells: np.array, + atom_types: List[int], + atomic: bool = False, + fparam: Optional[np.array] = None, + aparam: Optional[np.array] = None, + efield: Optional[np.array] = None + ) -> Tuple[np.ndarray, ...]: + """Evaluate the model with interface similar to the energy model. + Will return global tensor, component-wise force and virial + and optionally atomic tensor and atomic virial. + + Parameters + ---------- + coords + The coordinates of atoms. + The array should be of size nframes x natoms x 3 + cells + The cell of the region. + If None then non-PBC is assumed, otherwise using PBC. + The array should be of size nframes x 9 + atom_types + The atom types + The list should contain natoms ints + atomic + Whether to calculate atomic tensor and virial + fparam + Not used in this model + aparam + Not used in this model + efield + Not used in this model + + Returns + ------- + tensor + The global tensor. + shape: [nframes x nout] + force + The component-wise force (negative derivative) on each atom. + shape: [nframes x nout x natoms x 3] + virial + The component-wise virial of the tensor. + shape: [nframes x nout x 9] + atom_tensor + The atomic tensor. Only returned when atomic == True + shape: [nframes x natoms x nout] + atom_virial + The atomic virial. Only returned when atomic == True + shape: [nframes x nout x natoms x 9] + """ + assert self._support_gfv, \ + f"do not support eval_full with old tensor model" + + # standarize the shape of inputs + atom_types = np.array(atom_types, dtype = int).reshape([-1]) + natoms = atom_types.size + coords = np.reshape(np.array(coords), [-1, natoms * 3]) + nframes = coords.shape[0] + if cells is None: + pbc = False + cells = np.tile(np.eye(3), [nframes, 1]).reshape([nframes, 9]) + else: + pbc = True + cells = np.array(cells).reshape([nframes, 9]) + nout = self.output_dim + + # sort inputs + coords, atom_types, imap, sel_at, sel_imap = self.sort_input(coords, atom_types, sel_atoms = self.get_sel_type()) + + # make natoms_vec and default_mesh + natoms_vec = self.make_natoms_vec(atom_types) + assert(natoms_vec[0] == natoms) + + # evaluate + feed_dict_test = {} + feed_dict_test[self.t_natoms] = natoms_vec + feed_dict_test[self.t_type ] = np.tile(atom_types, [nframes,1]).reshape([-1]) + feed_dict_test[self.t_coord] = np.reshape(coords, [-1]) + feed_dict_test[self.t_box ] = np.reshape(cells , [-1]) + if pbc: + feed_dict_test[self.t_mesh ] = make_default_mesh(cells) + else: + feed_dict_test[self.t_mesh ] = np.array([], dtype = np.int32) + + t_out = [self.t_global_tensor, + self.t_force, + self.t_virial] + if atomic : + t_out += [self.t_tensor, + self.t_atom_virial] + + v_out = self.sess.run (t_out, feed_dict = feed_dict_test) + gt = v_out[0] # global tensor + force = v_out[1] + virial = v_out[2] + if atomic: + at = v_out[3] # atom tensor + av = v_out[4] # atom virial + + # please note here the shape are wrong! + force = self.reverse_map(np.reshape(force, [nframes*nout, natoms ,3]), imap) + if atomic: + at = self.reverse_map(np.reshape(at, [nframes, len(sel_at), nout]), sel_imap) + av = self.reverse_map(np.reshape(av, [nframes*nout, natoms, 9]), imap) + + # make sure the shapes are correct here + gt = np.reshape(gt, [nframes, nout]) + force = np.reshape(force, [nframes, nout, natoms, 3]) + virial = np.reshape(virial, [nframes, nout, 9]) + if atomic: + at = np.reshape(at, [nframes, len(sel_at), self.output_dim]) + av = np.reshape(av, [nframes, nout, natoms, 9]) + return gt, force, virial, at, av + else: + return gt, force, virial \ No newline at end of file diff --git a/deepmd/loss/tensor.py b/deepmd/loss/tensor.py index 8fbd286ad5..8f05b4e76e 100644 --- a/deepmd/loss/tensor.py +++ b/deepmd/loss/tensor.py @@ -56,7 +56,7 @@ def build (self, suffix): polar_hat = label_dict[self.label_name] atomic_polar_hat = label_dict["atomic_" + self.label_name] - polar = model_dict[self.tensor_name] + polar = tf.reshape(model_dict[self.tensor_name], [-1]) find_global = label_dict['find_' + self.label_name] find_atomic = label_dict['find_atomic_' + self.label_name] diff --git a/deepmd/model/tensor.py b/deepmd/model/tensor.py index 114a319edd..4cd41b2540 100644 --- a/deepmd/model/tensor.py +++ b/deepmd/model/tensor.py @@ -112,6 +112,9 @@ def build (self, name = 'output_dim', dtype = tf.int32) + natomsel = sum(natoms[2+type_i] for type_i in self.get_sel_type()) + nout = self.get_out_size() + dout \ = self.descrpt.build(coord_, atype_, @@ -123,16 +126,49 @@ def build (self, reuse = reuse) dout = tf.identity(dout, name='o_descriptor') rot_mat = self.descrpt.get_rot_mat() - rot_mat = tf.identity(rot_mat, name = 'o_rot_mat') + rot_mat = tf.identity(rot_mat, name = 'o_rot_mat'+suffix) output = self.fitting.build (dout, rot_mat, natoms, reuse = reuse, suffix = suffix) - output = tf.identity(output, name = 'o_' + self.model_type) - - return {self.model_type: output} + framesize = nout if "global" in self.model_type else natomsel * nout + output = tf.reshape(output, [-1, framesize], name = 'o_' + self.model_type + suffix) + + model_dict = {self.model_type: output} + + if "global" not in self.model_type: + gname = "global_"+self.model_type + atom_out = tf.reshape(output, [-1, natomsel, nout]) + global_out = tf.reduce_sum(atom_out, axis=1) + global_out = tf.reshape(global_out, [-1, nout], name="o_" + gname + suffix) + + out_cpnts = tf.split(atom_out, nout, axis=-1) + force_cpnts = [] + virial_cpnts = [] + atom_virial_cpnts = [] + + for out_i in out_cpnts: + force_i, virial_i, atom_virial_i \ + = self.descrpt.prod_force_virial(out_i, natoms) + force_cpnts.append (tf.reshape(force_i, [-1, 3*natoms[1]])) + virial_cpnts.append (tf.reshape(virial_i, [-1, 9])) + atom_virial_cpnts.append(tf.reshape(atom_virial_i, [-1, 9*natoms[1]])) + + # [nframe x nout x (natom x 3)] + force = tf.concat(force_cpnts, axis=1, name="o_force" + suffix) + # [nframe x nout x 9] + virial = tf.concat(virial_cpnts, axis=1, name="o_virial" + suffix) + # [nframe x nout x (natom x 9)] + atom_virial = tf.concat(atom_virial_cpnts, axis=1, name="o_atom_virial" + suffix) + + model_dict[gname] = global_out + model_dict["force"] = force + model_dict["virial"] = virial + model_dict["atom_virial"] = atom_virial + + return model_dict class WFCModel(TensorModel): diff --git a/source/api_cc/include/DeepTensor.h b/source/api_cc/include/DeepTensor.h index e39b52ae6c..4e1e47307b 100644 --- a/source/api_cc/include/DeepTensor.h +++ b/source/api_cc/include/DeepTensor.h @@ -40,10 +40,10 @@ class DeepTensor public: /** * @brief Evaluate the value by using this model. - * @param[out] value The value to evalute. - * @param[in] coord The coordinates of atoms. The array should be of size nframes x natoms x 3. + * @param[out] value The value to evalute, usually would be the atomic tensor. + * @param[in] coord The coordinates of atoms. The array should be of size natoms x 3. * @param[in] atype The atom types. The list should contain natoms ints. - * @param[in] box The cell of the region. The array should be of size nframes x 9. + * @param[in] box The cell of the region. The array should be of size 9. **/ void compute (std::vector & value, const std::vector & coord, @@ -51,10 +51,10 @@ class DeepTensor const std::vector & box); /** * @brief Evaluate the value by using this model. - * @param[out] value The value to evalute. - * @param[in] coord The coordinates of atoms. The array should be of size nframes x natoms x 3. + * @param[out] value The value to evalute, usually would be the atomic tensor. + * @param[in] coord The coordinates of atoms. The array should be of size natoms x 3. * @param[in] atype The atom types. The list should contain natoms ints. - * @param[in] box The cell of the region. The array should be of size nframes x 9. + * @param[in] box The cell of the region. The array should be of size 9. * @param[in] nghost The number of ghost atoms. * @param[in] inlist The input neighbour list. **/ @@ -65,6 +65,82 @@ class DeepTensor const int nghost, const InputNlist & inlist); /** + * @brief Evaluate the global tensor and component-wise force and virial. + * @param[out] global_tensor The global tensor to evalute. + * @param[out] force The component-wise force of the global tensor, size odim x natoms x 3. + * @param[out] virial The component-wise virial of the global tensor, size odim x 9. + * @param[in] coord The coordinates of atoms. The array should be of size natoms x 3. + * @param[in] atype The atom types. The list should contain natoms ints. + * @param[in] box The cell of the region. The array should be of size 9. + **/ + void compute (std::vector & global_tensor, + std::vector & force, + std::vector & virial, + const std::vector & coord, + const std::vector & atype, + const std::vector & box); + /** + * @brief Evaluate the global tensor and component-wise force and virial. + * @param[out] global_tensor The global tensor to evalute. + * @param[out] force The component-wise force of the global tensor, size odim x natoms x 3. + * @param[out] virial The component-wise virial of the global tensor, size odim x 9. + * @param[in] coord The coordinates of atoms. The array should be of size natoms x 3. + * @param[in] atype The atom types. The list should contain natoms ints. + * @param[in] box The cell of the region. The array should be of size 9. + * @param[in] nghost The number of ghost atoms. + * @param[in] inlist The input neighbour list. + **/ + void compute (std::vector & global_tensor, + std::vector & force, + std::vector & virial, + const std::vector & coord, + const std::vector & atype, + const std::vector & box, + const int nghost, + const InputNlist & inlist); + /** + * @brief Evaluate the global tensor and component-wise force and virial. + * @param[out] global_tensor The global tensor to evalute. + * @param[out] force The component-wise force of the global tensor, size odim x natoms x 3. + * @param[out] virial The component-wise virial of the global tensor, size odim x 9. + * @param[out] atom_tensor The atomic tensor value of the model, size natoms x odim. + * @param[out] atom_virial The component-wise atomic virial of the global tensor, size odim x natoms x 9. + * @param[in] coord The coordinates of atoms. The array should be of size natoms x 3. + * @param[in] atype The atom types. The list should contain natoms ints. + * @param[in] box The cell of the region. The array should be of size 9. + **/ + void compute (std::vector & global_tensor, + std::vector & force, + std::vector & virial, + std::vector & atom_tensor, + std::vector & atom_virial, + const std::vector & coord, + const std::vector & atype, + const std::vector & box); + /** + * @brief Evaluate the global tensor and component-wise force and virial. + * @param[out] global_tensor The global tensor to evalute. + * @param[out] force The component-wise force of the global tensor, size odim x natoms x 3. + * @param[out] virial The component-wise virial of the global tensor, size odim x 9. + * @param[out] atom_tensor The atomic tensor value of the model, size natoms x odim. + * @param[out] atom_virial The component-wise atomic virial of the global tensor, size odim x natoms x 9. + * @param[in] coord The coordinates of atoms. The array should be of size natoms x 3. + * @param[in] atype The atom types. The list should contain natoms ints. + * @param[in] box The cell of the region. The array should be of size 9. + * @param[in] nghost The number of ghost atoms. + * @param[in] inlist The input neighbour list. + **/ + void compute (std::vector & global_tensor, + std::vector & force, + std::vector & virial, + std::vector & atom_tensor, + std::vector & atom_virial, + const std::vector & coord, + const std::vector & atype, + const std::vector & box, + const int nghost, + const InputNlist & inlist); + /** * @brief Get the cutoff radius. * @return The cutoff radius. **/ @@ -99,6 +175,17 @@ class DeepTensor tensorflow::Session * session, const std::vector> & input_tensors, const AtomMap & atommap, + const std::vector & sel_fwd, + const int nghost = 0); + void run_model (std::vector & dglobal_tensor_, + std::vector & dforce_, + std::vector & dvirial_, + std::vector & datom_tensor_, + std::vector & datom_virial_, + tensorflow::Session * session, + const std::vector> & input_tensors, + const AtomMap & atommap, + const std::vector & sel_fwd, const int nghost = 0); void compute_inner (std::vector & value, const std::vector & coord, @@ -110,6 +197,24 @@ class DeepTensor const std::vector & box, const int nghost, const InputNlist& inlist); + void compute_inner (std::vector & global_tensor, + std::vector & force, + std::vector & virial, + std::vector & atom_tensor, + std::vector & atom_virial, + const std::vector & coord, + const std::vector & atype, + const std::vector & box); + void compute_inner (std::vector & global_tensor, + std::vector & force, + std::vector & virial, + std::vector & atom_tensor, + std::vector & atom_virial, + const std::vector & coord, + const std::vector & atype, + const std::vector & box, + const int nghost, + const InputNlist& inlist); }; } diff --git a/source/api_cc/include/common.h b/source/api_cc/include/common.h index 75fd61a6f7..7c769c4b1e 100644 --- a/source/api_cc/include/common.h +++ b/source/api_cc/include/common.h @@ -78,6 +78,27 @@ select_map(std::vector & out, const std::vector & fwd_map, const int & stride); +template +void +select_map(typename std::vector::iterator out, + const typename std::vector::const_iterator in, + const std::vector & fwd_map, + const int & stride); + +template +void +select_map_inv(std::vector & out, + const std::vector & in, + const std::vector & fwd_map, + const int & stride); + +template +void +select_map_inv(typename std::vector::iterator out, + const typename std::vector::const_iterator in, + const std::vector & fwd_map, + const int & stride); + /** * @brief Get the number of threads from the environment variable. * @param[out] num_intra_nthreads The number of intra threads. Read from TF_INTRA_OP_PARALLELISM_THREADS. diff --git a/source/api_cc/src/DeepPot.cc b/source/api_cc/src/DeepPot.cc index c862bb84fd..9158d1ad64 100644 --- a/source/api_cc/src/DeepPot.cc +++ b/source/api_cc/src/DeepPot.cc @@ -277,7 +277,7 @@ print_summary(const std::string &pre) const { std::cout << pre << "installed to: " + global_install_prefix << std::endl; std::cout << pre << "source: " + global_git_summ << std::endl; - std::cout << pre << "source brach: " + global_git_branch << std::endl; + std::cout << pre << "source branch: " + global_git_branch << std::endl; std::cout << pre << "source commit: " + global_git_hash << std::endl; std::cout << pre << "source commit at: " + global_git_date << std::endl; std::cout << pre << "surpport model ver.:" + global_model_version << std::endl; diff --git a/source/api_cc/src/DeepTensor.cc b/source/api_cc/src/DeepTensor.cc index a907ae0e19..e6ec684f28 100644 --- a/source/api_cc/src/DeepTensor.cc +++ b/source/api_cc/src/DeepTensor.cc @@ -52,6 +52,23 @@ init (const std::string & model, inited = true; } +void +DeepTensor:: +print_summary(const std::string &pre) const +{ + std::cout << pre << "installed to: " + global_install_prefix << std::endl; + std::cout << pre << "source: " + global_git_summ << std::endl; + std::cout << pre << "source branch: " + global_git_branch << std::endl; + std::cout << pre << "source commit: " + global_git_hash << std::endl; + std::cout << pre << "source commit at: " + global_git_date << std::endl; + std::cout << pre << "surpport model ver.:" + global_model_version << std::endl; + std::cout << pre << "build float prec: " + global_float_prec << std::endl; + std::cout << pre << "build with tf inc: " + global_tf_include_dir << std::endl; + std::cout << pre << "build with tf lib: " + global_tf_lib << std::endl; + std::cout << pre << "set tf intra_op_parallelism_threads: " << num_intra_nthreads << std::endl; + std::cout << pre << "set tf inter_op_parallelism_threads: " << num_inter_nthreads << std::endl; +} + template VT DeepTensor:: @@ -71,10 +88,11 @@ get_vector (std::vector & vec, const std::string & name) const void DeepTensor:: run_model (std::vector & d_tensor_, - Session * session, - const std::vector> & input_tensors, - const AtomMap &atommap, - const int nghost) + Session * session, + const std::vector> & input_tensors, + const AtomMap &atommap, + const std::vector & sel_fwd, + const int nghost) { unsigned nloc = atommap.get_type().size(); unsigned nall = nloc + nghost; @@ -91,16 +109,132 @@ run_model (std::vector & d_tensor_, &output_tensors)); Tensor output_t = output_tensors[0]; - assert (output_t.dims() == 1), "dim of output tensor should be 1"; - int o_size = output_t.dim_size(0); - + // Yixiao: newer model may output rank 2 tensor [nframes x (natoms x noutdim)] + // assert (output_t.dims() == 1), "dim of output tensor should be 1"; auto ot = output_t.flat (); + // this is an Eigen Tensor + int o_size = ot.size(); std::vector d_tensor (o_size); for (unsigned ii = 0; ii < o_size; ++ii){ d_tensor[ii] = ot(ii); } - d_tensor_ = d_tensor; + // now we map the type-sorted sel-atom tensor back to original order + // first we have to get the type-sorted select map + std::vector sel_srt = sel_fwd; + select_map(sel_srt, sel_fwd, atommap.get_fwd_map(), 1); + // remove those -1 that correspond to discarded atoms + std::remove(sel_srt.begin(), sel_srt.end(), -1); + // now map the tensor back + d_tensor_.resize(o_size); + select_map(d_tensor_, d_tensor, sel_srt, odim); +} + +void +DeepTensor:: +run_model (std::vector & dglobal_tensor_, + std::vector & dforce_, + std::vector & dvirial_, + std::vector & datom_tensor_, + std::vector & datom_virial_, + tensorflow::Session * session, + const std::vector> & input_tensors, + const AtomMap & atommap, + const std::vector & sel_fwd, + const int nghost) +{ + unsigned nloc = atommap.get_type().size(); + unsigned nall = nloc + nghost; + unsigned nsel = nloc - std::count(sel_fwd.begin(), sel_fwd.end(), -1); + if (nloc == 0) { + // return empty + dglobal_tensor_.clear(); + dforce_.clear(); + dvirial_.clear(); + return; + } + + std::vector output_tensors; + deepmd::check_status (session->Run(input_tensors, + {name_prefix(name_scope) + "o_global_" + model_type, + name_prefix(name_scope) + "o_force", + name_prefix(name_scope) + "o_virial", + name_prefix(name_scope) + "o_" + model_type, + name_prefix(name_scope) + "o_atom_virial"}, + {}, + &output_tensors)); + + Tensor output_gt = output_tensors[0]; + Tensor output_f = output_tensors[1]; + Tensor output_v = output_tensors[2]; + Tensor output_at = output_tensors[3]; + Tensor output_av = output_tensors[4]; + // this is the new model, output has to be rank 2 tensor + assert (output_gt.dims() == 2), "dim of output tensor should be 2"; + assert (output_f.dims() == 2), "dim of output tensor should be 2"; + assert (output_v.dims() == 2), "dim of output tensor should be 2"; + assert (output_at.dims() == 2), "dim of output tensor should be 2"; + assert (output_av.dims() == 2), "dim of output tensor should be 2"; + // also check the tensor shapes + assert (output_gt.dim_size(0) == 1), "nframes should match"; + assert (output_gt.dim_size(1) == odim), "dof of global tensor should be odim"; + assert (output_f.dim_size(0) == 1), "nframes should match"; + assert (output_f.dim_size(1) == odim * nall * 3), "dof of force should be odim * nall * 3"; + assert (output_v.dim_size(0) == 1), "nframes should match"; + assert (output_v.dim_size(1) == odim * 9), "dof of virial should be odim * 9"; + assert (output_at.dim_size(0) == 1), "nframes should match"; + assert (output_at.dim_size(1) == nsel * odim), "dof of atomic tensor should be nsel * odim"; + assert (output_av.dim_size(0) == 1), "nframes should match"; + assert (output_av.dim_size(1) == odim * nall * 9), "dof of atomic virial should be odim * nall * 9"; + + auto ogt = output_gt.flat (); + auto of = output_f.flat (); + auto ov = output_v.flat (); + auto oat = output_at.flat (); + auto oav = output_av.flat (); + + // global tensor + dglobal_tensor_.resize(odim); + for (unsigned ii = 0; ii < odim; ++ii){ + dglobal_tensor_[ii] = ogt(ii); + } + + // component-wise force + std::vector dforce (3 * nall * odim); + for (unsigned ii = 0; ii < odim * nall * 3; ++ii){ + dforce[ii] = of(ii); + } + dforce_ = dforce; + for (unsigned dd = 0; dd < odim; ++dd){ + atommap.backward (dforce_.begin() + (dd * nall * 3), dforce.begin() + (dd * nall * 3), 3); + } + + // component-wise virial + dvirial_.resize(odim * 9); + for (unsigned ii = 0; ii < odim * 9; ++ii){ + dvirial_[ii] = ov(ii); + } + + // atomic tensor + std::vector datom_tensor (nsel * odim); + for (unsigned ii = 0; ii < nsel * odim; ++ii){ + datom_tensor[ii] = oat(ii); + } + std::vector sel_srt = sel_fwd; + select_map(sel_srt, sel_fwd, atommap.get_fwd_map(), 1); + std::remove(sel_srt.begin(), sel_srt.end(), -1); + datom_tensor_.resize(nsel * odim); + select_map(datom_tensor_, datom_tensor, sel_srt, odim); + + // component-wise atomic virial + std::vector datom_virial (9 * nall * odim); + for (unsigned ii = 0; ii < odim * nall * 9; ++ii){ + datom_virial[ii] = oav(ii); + } + datom_virial_ = datom_virial; + for (unsigned dd = 0; dd < odim; ++dd){ + atommap.backward (datom_virial_.begin() + (dd * nall * 9), datom_virial.begin() + (dd * nall * 9), 9); + } } @@ -153,6 +287,109 @@ compute (std::vector & dtensor_, compute_inner(dtensor_, dcoord, datype, dbox, nghost_real, nlist); } +void +DeepTensor:: +compute (std::vector & dglobal_tensor_, + std::vector & dforce_, + std::vector & dvirial_, + const std::vector & dcoord_, + const std::vector & datype_, + const std::vector & dbox) +{ + std::vector tmp_at_, tmp_av_; + compute(dglobal_tensor_, dforce_, dvirial_, tmp_at_, tmp_av_, dcoord_, datype_, dbox); +} + +void +DeepTensor:: +compute (std::vector & dglobal_tensor_, + std::vector & dforce_, + std::vector & dvirial_, + const std::vector & dcoord_, + const std::vector & datype_, + const std::vector & dbox, + const int nghost, + const InputNlist & lmp_list) +{ + std::vector tmp_at_, tmp_av_; + compute(dglobal_tensor_, dforce_, dvirial_, tmp_at_, tmp_av_, dcoord_, datype_, dbox, nghost, lmp_list); +} + +void +DeepTensor:: +compute (std::vector & dglobal_tensor_, + std::vector & dforce_, + std::vector & dvirial_, + std::vector & datom_tensor_, + std::vector & datom_virial_, + const std::vector & dcoord_, + const std::vector & datype_, + const std::vector & dbox) +{ + std::vector dcoord, dforce, datom_virial; + std::vector datype, fwd_map, bkw_map; + int nghost_real; + select_real_atoms(fwd_map, bkw_map, nghost_real, dcoord_, datype_, 0, ntypes); + assert(nghost_real == 0); + // resize to nall_real + dcoord.resize(bkw_map.size() * 3); + datype.resize(bkw_map.size()); + // fwd map + select_map(dcoord, dcoord_, fwd_map, 3); + select_map(datype, datype_, fwd_map, 1); + compute_inner(dglobal_tensor_, dforce, dvirial_, datom_tensor_, datom_virial, dcoord, datype, dbox); + // bkw map + dforce_.resize(odim * fwd_map.size() * 3); + for(int kk = 0; kk < odim; ++kk){ + select_map(dforce_.begin() + kk * fwd_map.size() * 3, dforce.begin() + kk * bkw_map.size() * 3, bkw_map, 3); + } + datom_virial_.resize(odim * fwd_map.size() * 9); + for(int kk = 0; kk < odim; ++kk){ + select_map(datom_virial_.begin() + kk * fwd_map.size() * 9, datom_virial.begin() + kk * bkw_map.size() * 9, bkw_map, 9); + } +} + +void +DeepTensor:: +compute (std::vector & dglobal_tensor_, + std::vector & dforce_, + std::vector & dvirial_, + std::vector & datom_tensor_, + std::vector & datom_virial_, + const std::vector & dcoord_, + const std::vector & datype_, + const std::vector & dbox, + const int nghost, + const InputNlist & lmp_list) +{ + std::vector dcoord, dforce, datom_virial; + std::vector datype, fwd_map, bkw_map; + int nghost_real; + select_real_atoms(fwd_map, bkw_map, nghost_real, dcoord_, datype_, nghost, ntypes); + // resize to nall_real + dcoord.resize(bkw_map.size() * 3); + datype.resize(bkw_map.size()); + // fwd map + select_map(dcoord, dcoord_, fwd_map, 3); + select_map(datype, datype_, fwd_map, 1); + // internal nlist + NeighborListData nlist_data; + nlist_data.copy_from_nlist(lmp_list); + nlist_data.shuffle_exclude_empty(fwd_map); + InputNlist nlist; + nlist_data.make_inlist(nlist); + compute_inner(dglobal_tensor_, dforce, dvirial_, datom_tensor_, datom_virial, dcoord, datype, dbox, nghost_real, nlist); + // bkw map + dforce_.resize(odim * fwd_map.size() * 3); + for(int kk = 0; kk < odim; ++kk){ + select_map(dforce_.begin() + kk * fwd_map.size() * 3, dforce.begin() + kk * bkw_map.size() * 3, bkw_map, 3); + } + datom_virial_.resize(odim * fwd_map.size() * 9); + for(int kk = 0; kk < odim; ++kk){ + select_map(datom_virial_.begin() + kk * fwd_map.size() * 9, datom_virial.begin() + kk * bkw_map.size() * 9, bkw_map, 9); + } +} + void DeepTensor:: @@ -165,12 +402,17 @@ compute_inner (std::vector & dtensor_, int nloc = nall; AtomMap atommap (datype_.begin(), datype_.begin() + nloc); assert (nloc == atommap.get_type().size()); + + std::vector sel_fwd, sel_bkw; + int nghost_sel; + // this gives the raw selection map, will pass to run model + select_by_type(sel_fwd, sel_bkw, nghost_sel, dcoord_, datype_, 0, sel_type); std::vector> input_tensors; int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, cell_size, std::vector(), std::vector(), atommap, name_scope); assert (ret == nloc); - run_model (dtensor_, session, input_tensors, atommap); + run_model (dtensor_, session, input_tensors, atommap, sel_fwd); } void @@ -187,6 +429,77 @@ compute_inner (std::vector & dtensor_, AtomMap atommap (datype_.begin(), datype_.begin() + nloc); assert (nloc == atommap.get_type().size()); + std::vector sel_fwd, sel_bkw; + int nghost_sel; + // this gives the raw selection map, will pass to run model + select_by_type(sel_fwd, sel_bkw, nghost_sel, dcoord_, datype_, nghost, sel_type); + sel_fwd.resize(nloc); + + NeighborListData nlist_data; + nlist_data.copy_from_nlist(nlist_); + nlist_data.shuffle(atommap); + InputNlist nlist; + nlist_data.make_inlist(nlist); + + std::vector> input_tensors; + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, std::vector(), std::vector(), atommap, nghost, 0, name_scope); + assert (nloc == ret); + + run_model (dtensor_, session, input_tensors, atommap, sel_fwd, nghost); +} + +void +DeepTensor:: +compute_inner (std::vector & dglobal_tensor_, + std::vector & dforce_, + std::vector & dvirial_, + std::vector & datom_tensor_, + std::vector & datom_virial_, + const std::vector & dcoord_, + const std::vector & datype_, + const std::vector & dbox) +{ + int nall = dcoord_.size() / 3; + int nloc = nall; + AtomMap atommap (datype_.begin(), datype_.begin() + nloc); + assert (nloc == atommap.get_type().size()); + + std::vector sel_fwd, sel_bkw; + int nghost_sel; + // this gives the raw selection map, will pass to run model + select_by_type(sel_fwd, sel_bkw, nghost_sel, dcoord_, datype_, 0, sel_type); + + std::vector> input_tensors; + int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, cell_size, std::vector(), std::vector(), atommap, name_scope); + assert (ret == nloc); + + run_model (dglobal_tensor_, dforce_, dvirial_, datom_tensor_, datom_virial_, session, input_tensors, atommap, sel_fwd); +} + +void +DeepTensor:: +compute_inner (std::vector & dglobal_tensor_, + std::vector & dforce_, + std::vector & dvirial_, + std::vector & datom_tensor_, + std::vector & datom_virial_, + const std::vector & dcoord_, + const std::vector & datype_, + const std::vector & dbox, + const int nghost, + const InputNlist & nlist_) +{ + int nall = dcoord_.size() / 3; + int nloc = nall - nghost; + AtomMap atommap (datype_.begin(), datype_.begin() + nloc); + assert (nloc == atommap.get_type().size()); + + std::vector sel_fwd, sel_bkw; + int nghost_sel; + // this gives the raw selection map, will pass to run model + select_by_type(sel_fwd, sel_bkw, nghost_sel, dcoord_, datype_, nghost, sel_type); + sel_fwd.resize(nloc); + NeighborListData nlist_data; nlist_data.copy_from_nlist(nlist_); nlist_data.shuffle(atommap); @@ -197,5 +510,6 @@ compute_inner (std::vector & dtensor_, int ret = session_input_tensors (input_tensors, dcoord_, ntypes, datype_, dbox, nlist, std::vector(), std::vector(), atommap, nghost, 0, name_scope); assert (nloc == ret); - run_model (dtensor_, session, input_tensors, atommap, nghost); + run_model (dglobal_tensor_, dforce_, dvirial_, datom_tensor_, datom_virial_, session, input_tensors, atommap, sel_fwd, nghost); } + diff --git a/source/api_cc/src/common.cc b/source/api_cc/src/common.cc index 579216cb2c..92883f04fe 100644 --- a/source/api_cc/src/common.cc +++ b/source/api_cc/src/common.cc @@ -574,6 +574,68 @@ select_map(std::vector & out, } } +template +void +deepmd:: +select_map(typename std::vector::iterator out, + const typename std::vector::const_iterator in, + const std::vector & idx_map, + const int & stride) +{ + for (int ii = 0; ii < idx_map.size(); ++ii){ + if (idx_map[ii] >= 0) { + int to_ii = idx_map[ii]; + for (int dd = 0; dd < stride; ++dd){ + *(out + to_ii * stride + dd) = *(in + ii * stride + dd); + } + } + } +} + +// sel_map(_,_,fwd_map,_) == sel_map_inv(_,_,bkw_map,_) +template +void +deepmd:: +select_map_inv(std::vector & out, + const std::vector & in, + const std::vector & idx_map, + const int & stride) +{ +#ifdef DEBUG + assert(in.size() / stride * stride == in.size()), "in size should be multiples of stride" +#endif + for (int ii = 0; ii < out.size() / stride; ++ii){ +#ifdef DEBUG + assert(ii < idx_map.size()), "idx goes over the idx map size"; + assert(idx_map[ii] < in.size()), "from idx goes over the in size"; +#endif + if (idx_map[ii] >= 0) { + int from_ii = idx_map[ii]; + for (int dd = 0; dd < stride; ++dd){ + out[ii * stride + dd] = in[from_ii * stride + dd]; + } + } + } +} + +template +void +deepmd:: +select_map_inv(typename std::vector::iterator out, + const typename std::vector::const_iterator in, + const std::vector & idx_map, + const int & stride) +{ + for (int ii = 0; ii < idx_map.size(); ++ii){ + if (idx_map[ii] >= 0) { + int from_ii = idx_map[ii]; + for (int dd = 0; dd < stride; ++dd){ + *(out + ii * stride + dd) = *(in + from_ii * stride + dd); + } + } + } +} + template int @@ -594,6 +656,33 @@ select_map( const std::vector & idx_map, const int & stride); +template +void +deepmd:: +select_map( + typename std::vector::iterator out, + const typename std::vector::const_iterator in, + const std::vector & idx_map, + const int & stride); + +template +void +deepmd:: +select_map_inv( + std::vector & out, + const std::vector & in, + const std::vector & idx_map, + const int & stride); + +template +void +deepmd:: +select_map_inv( + typename std::vector::iterator out, + const typename std::vector::const_iterator in, + const std::vector & idx_map, + const int & stride); + template float @@ -614,6 +703,33 @@ select_map( const std::vector & idx_map, const int & stride); +template +void +deepmd:: +select_map( + typename std::vector::iterator out, + const typename std::vector::const_iterator in, + const std::vector & idx_map, + const int & stride); + +template +void +deepmd:: +select_map_inv( + std::vector & out, + const std::vector & in, + const std::vector & idx_map, + const int & stride); + +template +void +deepmd:: +select_map_inv( + typename std::vector::iterator out, + const typename std::vector::const_iterator in, + const std::vector & idx_map, + const int & stride); + template double @@ -634,6 +750,33 @@ select_map( const std::vector & idx_map, const int & stride); +template +void +deepmd:: +select_map( + typename std::vector::iterator out, + const typename std::vector::const_iterator in, + const std::vector & idx_map, + const int & stride); + +template +void +deepmd:: +select_map_inv( + std::vector & out, + const std::vector & in, + const std::vector & idx_map, + const int & stride); + +template +void +deepmd:: +select_map_inv( + typename std::vector::iterator out, + const typename std::vector::const_iterator in, + const std::vector & idx_map, + const int & stride); + template deepmd::STRINGTYPE @@ -653,3 +796,30 @@ select_map( const std::vector & in, const std::vector & idx_map, const int & stride); + +template +void +deepmd:: +select_map( + typename std::vector::iterator out, + const typename std::vector::const_iterator in, + const std::vector & idx_map, + const int & stride); + +template +void +deepmd:: +select_map_inv( + std::vector & out, + const std::vector & in, + const std::vector & idx_map, + const int & stride); + +template +void +deepmd:: +select_map_inv( + typename std::vector::iterator out, + const typename std::vector::const_iterator in, + const std::vector & idx_map, + const int & stride); diff --git a/source/api_cc/tests/test_deepdipole.cc b/source/api_cc/tests/test_deepdipole.cc index fbc7388f7a..94f21ec675 100644 --- a/source/api_cc/tests/test_deepdipole.cc +++ b/source/api_cc/tests/test_deepdipole.cc @@ -33,7 +33,7 @@ class TestInferDeepDipole : public ::testing::Test std::vector expected_d = { -9.274180565967479195e-01,2.698028341272042496e+00,2.521268387140979117e-01,2.927260638453461628e+00,-8.571926301526779923e-01,1.667785136187720063e+00 }; - int natoms; + int natoms = 6; deepmd::DeepTensor dp; @@ -51,8 +51,6 @@ class TestInferDeepDipole : public ::testing::Test // tensorflow::protobuf::TextFormat::PrintToString(graph_def, &txt); dp.init("deepdipole.pb"); - - natoms = expected_d.size(); }; void TearDown() override { @@ -79,6 +77,7 @@ TEST_F(TestInferDeepDipole, cpu_build_nlist) } } + TEST_F(TestInferDeepDipole, cpu_lmp_nlist) { float rc = dp.cutoff(); @@ -103,3 +102,305 @@ TEST_F(TestInferDeepDipole, cpu_lmp_nlist) } } + + +class TestInferDeepDipoleNew : public ::testing::Test +{ +protected: + std::vector coord = { + 12.83, 2.56, 2.18, + 12.09, 2.87, 2.74, + 00.25, 3.32, 1.68, + 3.36, 3.00, 1.81, + 3.51, 2.51, 2.60, + 4.27, 3.22, 1.56 + }; + std::vector atype = { + 0, 1, 1, 0, 1, 1 + }; + std::vector box = { + 13., 0., 0., 0., 13., 0., 0., 0., 13. + }; + std::vector expected_t = { + -1.128427726201255282e-01, 2.654103846999197880e-01, 2.625816377288122533e-02, 3.027556488877700680e-01, -7.475444785689989990e-02, 1.526291164572509684e-01 + }; + std::vector expected_f = { + 8.424897862241968738e-02, -3.823566783202275721e-02, 3.570797165027734810e-01, 6.102563129736437997e-02, -1.351209759852018133e-01, -2.438224487466488510e-01, -1.403204771681088869e-01, 1.719596545791735875e-01, -1.136584427103610045e-01, 2.761686212947551955e-02, -7.247860200915196005e-02, 6.208831127377397591e-02, -2.605870723577520809e-01, -4.504074577536486268e-02, 7.340240097998475266e-02, 2.280160774766013809e-01, 1.189163370225677641e-01, -1.350895372995223886e-01, -4.294311497114180337e-02, 1.524802094783661577e-01, 1.070451777645946290e-01, -1.259336332521076574e-01, -2.087610788959351760e-01, 9.447141346538817652e-02, 1.668125597515543457e-01, 5.487037060760904805e-02, -2.014994036104674757e-01, -7.411985441205551361e-02, 3.614456658821710300e-01, 2.901174891391154476e-01, -4.871926969937838414e-02, -1.252747945819455699e-01, -2.555459318266457558e-01, 1.249033125831290059e-01, -2.347603724902655176e-01, -3.458874493198500766e-02, 3.563990394229877290e-01, 1.052342031228763047e-01, 1.907268232932498031e-01, -2.432737821373903708e-01, 1.016781829972335099e-01, -7.707616437996064884e-02, -1.139199805053340564e-01, -2.068592154909300040e-01, -1.156337826476897951e-01, 6.583817133933017596e-02, 2.902207490750204344e-01, 9.945482314729316153e-02, 7.986986504051810098e-02, -2.549975565538568079e-01, 1.275343199697696051e-01, -1.449133131601115787e-01, -3.527636315034351350e-02, -2.250060193826620980e-01 + }; + std::vector expected_v = { + 3.479789535931299138e-02, 4.337414719007849292e-03, -3.647371468256610082e-03, 8.053492919528318708e-03, 1.003834811499279773e-03, -8.441338187607602033e-04, -6.695998268698949256e-03, -8.346286793845711892e-04, 7.018468440279366279e-04, -4.515896716004976635e-02, 1.891794570218296306e-02, 3.417435352652402336e-02, 9.998952222904963771e-02, -4.188750255541257711e-02, -7.566774655171297492e-02, 1.804286120725206444e-01, -7.558495911146115298e-02, -1.365405712981232755e-01, -1.002593446510361419e-01, -1.117945222697993429e-01, 7.449172735713084637e-02, 7.770237313970995707e-02, 1.313723119887387492e-01, -8.655414676270002661e-02, -4.973937467461287537e-02, -8.663006083493235421e-02, 5.703914957966123994e-02, -3.382231967662072125e-02, -4.215813217482468345e-03, 3.545115660155720612e-03, -8.247565860499378454e-03, -1.028025206407854253e-03, 8.644757417520612143e-04, 6.761330949063471332e-03, 8.427721296283078580e-04, -7.086947453692606178e-04, -1.622698090933780493e-02, 1.305372051650728060e-01, -2.082599910094798112e-01, -7.109985131471197733e-03, 2.202585658101286273e-02, -3.554509763049529952e-02, 1.436400379134906459e-02, -3.554915857551419617e-02, 5.763638171798115412e-02, 2.074946305037073946e-01, 5.016353704485233822e-02, -5.700401936915034523e-02, 1.082138666905367308e-01, 2.616159414496492877e-02, -2.972908425564194101e-02, -1.229314789425654392e-01, -2.971969820589494271e-02, 3.377238432488059716e-02, 7.622024445219390681e-03, 9.500540384976005961e-04, -7.989090778275298932e-04, -2.952148931042387209e-02, -3.679732378636401541e-03, 3.094320409307891630e-03, -9.534268115386618486e-04, -1.188407357158671420e-04, 9.993425503379762414e-05, 9.319088860655992679e-02, -3.903942630815338682e-02, -7.052283462118023871e-02, 1.544831983829924038e-01, -6.471593445773991815e-02, -1.169062041817236081e-01, -6.990884596438741438e-02, 2.928613817427033750e-02, 5.290399154061733306e-02, 7.491400658274136037e-02, 1.273824184577304897e-01, -8.391492311946648075e-02, 3.543872837542783732e-02, 4.324623973455964804e-02, -2.873418641045778418e-02, -8.444981234074398768e-02, -1.531171183141288306e-01, 1.007308415346981068e-01, -6.396885751015785743e-03, -7.973455327045167592e-04, 6.704951070469818575e-04, 2.915483242551994078e-02, 3.634030104030812076e-03, -3.055888951116827318e-03, 6.608747470375698129e-04, 8.237532257692081912e-05, -6.927015762150179410e-05, -6.099175331115514430e-03, 2.402310352789886402e-02, -3.861491558256636286e-02, -2.583867422346154685e-02, 6.050621302336450097e-02, -9.822840263095998503e-02, -3.827994718203701213e-02, 1.252239810257823327e-01, -2.018867305507059950e-01, 1.136620144506474833e-01, 2.747872876828840599e-02, -3.122582814578225147e-02, -2.136319389661417989e-01, -5.164728194785846160e-02, 5.869009312256637939e-02, -3.147575788810638014e-02, -7.609523885036708832e-03, 8.647186232996251914e-03, -5.990706138603461330e-03, -7.467169124604876177e-04, 6.279210400235934152e-04, -9.287887182821588476e-04, -1.157696985960763821e-04, 9.735179200124630735e-05, -2.966271471326579340e-02, -3.697335544996301071e-03, 3.109123071928715683e-03, 1.800225987816693740e-01, -7.541487246259104271e-02, -1.362333179969384966e-01, -7.524185541795300192e-02, 3.152023672914239238e-02, 5.693978247845072477e-02, 5.703636164117102669e-02, -2.389361095778780308e-02, -4.316265205277792366e-02, -4.915584336537091176e-02, -8.674240294138457763e-02, 5.709724154860432860e-02, -8.679070528401405804e-02, -1.572017650485294793e-01, 1.034201569997979520e-01, -3.557746655862283752e-02, -8.626268394893003844e-02, 5.645546718878535764e-02, 6.848075985139651621e-03, 8.535845420570665554e-04, -7.177870012752625602e-04, 8.266638576582277997e-04, 1.030402542123569647e-04, -8.664748649675494882e-05, 2.991751925173294011e-02, 3.729095884068693231e-03, -3.135830629785046203e-03, 1.523793442834292522e-02, -3.873020552543556677e-02, 6.275576045602117292e-02, -3.842536616563556329e-02, 1.249268983543572881e-01, -2.014296501045876875e-01, 1.288704808602599873e-02, -6.326999354443738066e-02, 1.014064886873057153e-01, -1.318711149757016143e-01, -3.188092889522457091e-02, 3.622832829002789468e-02, -3.210149046681261276e-02, -7.760799893075580151e-03, 8.819090787585878374e-03, -2.047554776382226327e-01, -4.950132426418570042e-02, 5.625150484566552450e-02 + }; + std::vector expected_gt; + std::vector expected_gv; + int natoms = 6; + int nsel = 2; + int odim; + deepmd::DeepTensor dp; + + void SetUp() override { + std::string file_name = "../../tests/infer/deepdipole_new.pbtxt"; + int fd = open(file_name.c_str(), O_RDONLY); + tensorflow::protobuf::io::ZeroCopyInputStream* input = new tensorflow::protobuf::io::FileInputStream(fd); + tensorflow::GraphDef graph_def; + tensorflow::protobuf::TextFormat::Parse(input, &graph_def); + delete input; + std::fstream output("deepdipole_new.pb", std::ios::out | std::ios::trunc | std::ios::binary); + graph_def.SerializeToOstream(&output); + // check the string by the following commands + // string txt; + // tensorflow::protobuf::TextFormat::PrintToString(graph_def, &txt); + dp.init("deepdipole_new.pb"); + odim = dp.output_dim (); + + expected_gt.resize(odim); + for(int ii = 0; ii < nsel; ++ii){ + for(int dd = 0; dd < odim; ++dd){ + expected_gt[dd] += expected_t[ii*odim+dd]; + } + } + + expected_gv.resize(odim * 9); + for (int kk = 0; kk < odim; ++kk){ + for(int ii = 0; ii < natoms; ++ii){ + for(int dd = 0; dd < 9; ++dd){ + expected_gv[kk*9 + dd] += expected_v[kk*natoms*9 + ii*9 + dd]; + } + } + } + }; + + void TearDown() override { + remove( "deepdipole_new.pb" ) ; + }; +}; + + +TEST_F(TestInferDeepDipoleNew, cpu_build_nlist) +{ + EXPECT_EQ(dp.cutoff(), 4.); + EXPECT_EQ(dp.numb_types(), 2); + EXPECT_EQ(dp.output_dim(), 3); + std::vector sel_types = dp.sel_types(); + EXPECT_EQ(sel_types.size(), 1); + EXPECT_EQ(sel_types[0], 0); + + std::vector gt, ff, vv, at, av; + + dp.compute(at, coord, atype, box); + EXPECT_EQ(at.size(), expected_t.size()); + for(int ii = 0; ii < expected_t.size(); ++ii){ + EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + } + + dp.compute(gt, ff, vv, coord, atype, box); + EXPECT_EQ(gt.size(), expected_gt.size()); + for(int ii = 0; ii < expected_gt.size(); ++ii){ + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + } + EXPECT_EQ(ff.size(), expected_f.size()); + for(int ii = 0; ii < expected_f.size(); ++ii){ + EXPECT_LT(fabs(ff[ii] - expected_f[ii]), 1e-10); + } + EXPECT_EQ(vv.size(), expected_gv.size()); + for(int ii = 0; ii < expected_gv.size(); ++ii){ + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + } + + dp.compute(gt, ff, vv, at, av, coord, atype, box); + EXPECT_EQ(gt.size(), expected_gt.size()); + for(int ii = 0; ii < expected_gt.size(); ++ii){ + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + } + EXPECT_EQ(ff.size(), expected_f.size()); + for(int ii = 0; ii < expected_f.size(); ++ii){ + EXPECT_LT(fabs(ff[ii] - expected_f[ii]), 1e-10); + } + EXPECT_EQ(vv.size(), expected_gv.size()); + for(int ii = 0; ii < expected_gv.size(); ++ii){ + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + } + EXPECT_EQ(at.size(), expected_t.size()); + for(int ii = 0; ii < expected_t.size(); ++ii){ + EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + } + EXPECT_EQ(av.size(), expected_v.size()); + for(int ii = 0; ii < expected_v.size(); ++ii){ + EXPECT_LT(fabs(av[ii] - expected_v[ii]), 1e-10); + } +} + + +TEST_F(TestInferDeepDipoleNew, cpu_lmp_nlist) +{ + float rc = dp.cutoff(); + int nloc = coord.size() / 3; + std::vector coord_cpy; + std::vector atype_cpy, mapping; + std::vector ilist(nloc), numneigh(nloc); + std::vector firstneigh(nloc); + std::vector > nlist_data; + deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); + _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, + coord, atype, box, rc); + int nall = coord_cpy.size() / 3; + convert_nlist(inlist, nlist_data); + + std::vector gt, ff, vv, at, av; + + dp.compute(at, coord_cpy, atype_cpy, box, nall-nloc, inlist); + + EXPECT_EQ(at.size(), expected_t.size()); + for(int ii = 0; ii < expected_t.size(); ++ii){ + EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + } + + + dp.compute(gt, ff, vv, coord_cpy, atype_cpy, box, nall-nloc, inlist); + + EXPECT_EQ(gt.size(), expected_gt.size()); + for(int ii = 0; ii < expected_gt.size(); ++ii){ + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + } + // remove ghost atoms + std::vector rff (odim * nloc * 3); + for(int kk = 0; kk < odim; ++kk){ + _fold_back(rff.begin() + kk * nloc * 3, ff.begin() + kk * nall * 3, mapping, nloc, nall, 3); + } + EXPECT_EQ(rff.size(), expected_f.size()); + for(int ii = 0; ii < expected_f.size(); ++ii){ + EXPECT_LT(fabs(rff[ii] - expected_f[ii]), 1e-10); + } + // virial + EXPECT_EQ(vv.size(), expected_gv.size()); + for(int ii = 0; ii < expected_gv.size(); ++ii){ + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + } + + + dp.compute(gt, ff, vv, at, av, coord_cpy, atype_cpy, box, nall-nloc, inlist); + + EXPECT_EQ(gt.size(), expected_gt.size()); + for(int ii = 0; ii < expected_gt.size(); ++ii){ + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + } + // remove ghost atoms + for(int kk = 0; kk < odim; ++kk){ + _fold_back(rff.begin() + kk * nloc * 3, ff.begin() + kk * nall * 3, mapping, nloc, nall, 3); + } + EXPECT_EQ(rff.size(), expected_f.size()); + for(int ii = 0; ii < expected_f.size(); ++ii){ + EXPECT_LT(fabs(rff[ii] - expected_f[ii]), 1e-10); + } + // virial + EXPECT_EQ(vv.size(), expected_gv.size()); + for(int ii = 0; ii < expected_gv.size(); ++ii){ + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + } + // atom tensor + EXPECT_EQ(at.size(), expected_t.size()); + for(int ii = 0; ii < expected_t.size(); ++ii){ + EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + } + // atom virial + std::vector rav (odim * nloc * 9); + for(int kk = 0; kk < odim; ++kk){ + _fold_back(rav.begin() + kk * nloc * 9, av.begin() + kk * nall * 9, mapping, nloc, nall, 9); + } + EXPECT_EQ(rav.size(), expected_v.size()); + for(int ii = 0; ii < expected_v.size(); ++ii){ + EXPECT_LT(fabs(rav[ii] - expected_v[ii]), 1e-10); + } +} + + + +class TestInferDeepDipoleFake : public ::testing::Test +{ +protected: + std::vector coord = { + 12.83, 2.56, 2.18, + 12.09, 2.87, 2.74, + 00.25, 3.32, 1.68, + 3.36, 3.00, 1.81, + 3.51, 2.51, 2.60, + 4.27, 3.22, 1.56 + }; + std::vector atype = { + 0, 1, 1, 0, 1, 1 + }; + std::vector box = { + 13., 0., 0., 0., 13., 0., 0., 0., 13. + }; + std::vector expected_d = { + -3.186217894664857830e-01, 1.082220317383403296e+00, 5.646623185237639730e-02, 7.426508038929955369e-01, -3.115996324658170114e-01, -5.619108089573777720e-01, -4.181578166874897473e-01, -7.579762930974662805e-01, 4.980618433125854616e-01, 1.059635561913792712e+00, -2.641989315855929332e-01, 5.307984468104405273e-01, -1.484512535335152095e-01, 4.978588497891502374e-01, -8.022467807199461509e-01, -9.165936539882671985e-01, -2.238112120606238209e-01, 2.553133145814526217e-01 + }; + int natoms = 6; + + deepmd::DeepTensor dp; + + void SetUp() override { + std::string file_name = "../../tests/infer/deepdipole_fake.pbtxt"; + int fd = open(file_name.c_str(), O_RDONLY); + tensorflow::protobuf::io::ZeroCopyInputStream* input = new tensorflow::protobuf::io::FileInputStream(fd); + tensorflow::GraphDef graph_def; + tensorflow::protobuf::TextFormat::Parse(input, &graph_def); + delete input; + std::fstream output("deepdipole_fake.pb", std::ios::out | std::ios::trunc | std::ios::binary); + graph_def.SerializeToOstream(&output); + // check the string by the following commands + // string txt; + // tensorflow::protobuf::TextFormat::PrintToString(graph_def, &txt); + + dp.init("deepdipole_fake.pb"); + }; + + void TearDown() override { + remove( "deepdipole_fake.pb" ) ; + }; +}; + + +TEST_F(TestInferDeepDipoleFake, cpu_build_nlist) +{ + EXPECT_EQ(dp.cutoff(), 2.); + EXPECT_EQ(dp.numb_types(), 2); + EXPECT_EQ(dp.output_dim(), 3); + std::vector sel_types = dp.sel_types(); + EXPECT_EQ(sel_types.size(), 2); + EXPECT_EQ(sel_types[0], 0); + EXPECT_EQ(sel_types[1], 1); + + std::vector value; + dp.compute(value, coord, atype, box); + + EXPECT_EQ(value.size(), expected_d.size()); + for(int ii = 0; ii < expected_d.size(); ++ii){ + EXPECT_LT(fabs(value[ii] - expected_d[ii]), 1e-10); + } +} + + +TEST_F(TestInferDeepDipoleFake, cpu_lmp_nlist) +{ + float rc = dp.cutoff(); + int nloc = coord.size() / 3; + std::vector coord_cpy; + std::vector atype_cpy, mapping; + std::vector ilist(nloc), numneigh(nloc); + std::vector firstneigh(nloc); + std::vector > nlist_data; + deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); + _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, + coord, atype, box, rc); + int nall = coord_cpy.size() / 3; + convert_nlist(inlist, nlist_data); + + std::vector value; + dp.compute(value, coord_cpy, atype_cpy, box, nall-nloc, inlist); + + EXPECT_EQ(value.size(), expected_d.size()); + for(int ii = 0; ii < expected_d.size(); ++ii){ + EXPECT_LT(fabs(value[ii] - expected_d[ii]), 1e-10); + } +} + diff --git a/source/api_cc/tests/test_deeppolar.cc b/source/api_cc/tests/test_deeppolar.cc index a76e84179a..3dfc34c1d0 100644 --- a/source/api_cc/tests/test_deeppolar.cc +++ b/source/api_cc/tests/test_deeppolar.cc @@ -79,6 +79,7 @@ TEST_F(TestInferDeepPolar, cpu_build_nlist) } } + TEST_F(TestInferDeepPolar, cpu_lmp_nlist) { float rc = dp.cutoff(); @@ -103,3 +104,213 @@ TEST_F(TestInferDeepPolar, cpu_lmp_nlist) } } + + +class TestInferDeepPolarNew : public ::testing::Test +{ +protected: + std::vector coord = { + 12.83, 2.56, 2.18, + 12.09, 2.87, 2.74, + 00.25, 3.32, 1.68, + 3.36, 3.00, 1.81, + 3.51, 2.51, 2.60, + 4.27, 3.22, 1.56 + }; + std::vector atype = { + 0, 1, 1, 0, 1, 1 + }; + std::vector box = { + 13., 0., 0., 0., 13., 0., 0., 0., 13. + }; + std::vector expected_t = { + 1.936327241487292961e+00, 5.198696351735779264e-02, 3.888336625074450149e-03, 5.198696351735781346e-02, 1.764967784387830196e+00, -1.354658545697527347e-02, 3.888336625074451016e-03, -1.354658545697527000e-02, 1.939288409902199639e+00, 1.786740420980893029e+00, 4.868765294055640847e-02, -9.812132615180739481e-02, 4.868765294055640847e-02, 1.925999147066305373e+00, 2.895028407651457567e-02, -9.812132615180743644e-02, 2.895028407651457220e-02, 1.883109989034779996e+00 + }; + std::vector expected_f = { + 5.305178446980116092e-02, -1.127314829623577049e-02, 1.136493514861047216e-01, 5.598130220328862322e-05, -4.352126938892845326e-02, -7.700608888887500170e-02, -1.050015668789053697e-01, 5.882396336737016895e-02, -3.723875897544067642e-02, -7.850322286760008650e-02, 7.279117637753844405e-02, -6.178451060078461732e-02, 3.404361490778949895e-01, 5.447934529195214842e-02, -8.698375128815737101e-02, -2.100391251033939810e-01, -1.313000673516965255e-01, 1.493637582671529240e-01, -9.589318874236771317e-02, 6.285887854370801608e-02, -1.824395427630142175e-01, -3.264267092869802683e-02, 3.637498661083633789e-02, 1.524859582123189172e-01, 1.442484990808054202e-01, -8.957992476622803069e-02, 3.076469140583825215e-02, 4.909822745881124717e-02, -2.559151672032903835e-01, -1.522830913546814324e-01, -2.885480042033320910e-02, 7.730841025065784966e-02, 1.553301391955271560e-01, -3.595606644821771475e-02, 1.689528165643162105e-01, -3.858154695988691516e-03, 5.018843026262573281e-02, 1.756005154318779349e-02, 3.489323893614350303e-02, -4.020411124876955428e-02, 2.218648284685413238e-02, -8.086177159691650476e-03, -2.222392408702593067e-02, -3.825892777133557687e-02, -1.689393838770965675e-02, -5.465804822761769627e-02, -1.398775875506316768e-01, -1.165702490994514756e-01, 5.449067849718619572e-02, 1.588580450812354106e-01, -8.209560373418453572e-02, 1.240697480360127003e-02, -2.046806414931008622e-02, 1.887527294448937965e-01, -9.589318874236771317e-02, 6.285887854370801608e-02, -1.824395427630142175e-01, -3.264267092869802683e-02, 3.637498661083633789e-02, 1.524859582123189172e-01, 1.442484990808054202e-01, -8.957992476622803069e-02, 3.076469140583825215e-02, 4.909822745881124717e-02, -2.559151672032903835e-01, -1.522830913546814324e-01, -2.885480042033320910e-02, 7.730841025065784966e-02, 1.553301391955271560e-01, -3.595606644821771475e-02, 1.689528165643162105e-01, -3.858154695988691516e-03, 4.038746042068122599e-02, -2.549213597407858356e-01, -1.131801705114504619e-01, 1.489732376295762606e-01, 2.734584831542113958e-01, -1.125511889088352951e-01, -1.908551011160136424e-01, -2.400995606986339528e-02, 2.255650484976146619e-01, -2.185213968874370055e-02, 1.475333123369945709e-01, 9.584417756169674729e-02, -1.576380405016522893e-02, -5.153693137796186430e-02, -8.489897831367294867e-02, 3.911034680466508873e-02, -9.052354830259493057e-02, -1.077888832535272776e-02, -1.970229486427777510e-01, -6.538978166042377915e-02, -1.570533119125729904e-01, 1.417940206277617798e-01, -4.684714285705613573e-02, 6.070882964241105378e-02, 5.715183445260185735e-02, 1.138024049318459713e-01, 9.374622673558237473e-02, 3.096927839536914306e-02, -9.232883741117139942e-02, -6.499836527010099951e-02, 2.839980861544661936e-02, 8.097497759757724123e-03, 1.006700103228213017e-01, -6.129199344840163821e-02, 8.266585923704758421e-02, -3.307338951814068478e-02, 5.018843026262574669e-02, 1.756005154318778308e-02, 3.489323893614350997e-02, -4.020411124876957509e-02, 2.218648284685414279e-02, -8.086177159691652211e-03, -2.222392408702593067e-02, -3.825892777133557687e-02, -1.689393838770965675e-02, -5.465804822761770321e-02, -1.398775875506316491e-01, -1.165702490994514756e-01, 5.449067849718619572e-02, 1.588580450812354106e-01, -8.209560373418453572e-02, 1.240697480360125615e-02, -2.046806414931009316e-02, 1.887527294448937965e-01, -1.970229486427777510e-01, -6.538978166042375140e-02, -1.570533119125729626e-01, 1.417940206277618076e-01, -4.684714285705613573e-02, 6.070882964241105378e-02, 5.715183445260184347e-02, 1.138024049318459713e-01, 9.374622673558236086e-02, 3.096927839536912919e-02, -9.232883741117139942e-02, -6.499836527010102727e-02, 2.839980861544661589e-02, 8.097497759757731062e-03, 1.006700103228213017e-01, -6.129199344840162433e-02, 8.266585923704758421e-02, -3.307338951814066397e-02, -3.078161564779093723e-02, -8.748776750553553111e-03, -2.162930108693108394e-02, 2.135313622214399243e-02, -8.845621737097757523e-03, 9.365293934359546560e-03, 8.562579091543631032e-03, 1.772751551871581607e-02, 1.573655414890783033e-02, -3.649820158632081230e-02, -1.904914900326310223e-01, -1.076542087674599024e-01, -5.186655049718805199e-02, 1.686765146765009937e-01, -6.620206332305828001e-02, 8.923065241761217459e-02, 2.168185832506550753e-02, 1.703837250941818704e-01 + }; + std::vector expected_v = { + -2.123013313652813774e-03, -2.646248889538913257e-04, 2.225254748021367093e-04, 9.843593195853941446e-04, 1.226963457840150472e-04, -1.031764725911038809e-04, -8.467513732241481721e-04, -1.055440805151912256e-04, 8.875297679686559459e-05, 1.829118379697145316e-02, 2.302438731350108913e-03, -1.890198823577125386e-03, 3.300229266409118040e-02, -1.339230641165423293e-02, -2.445540228188634868e-02, 5.127826101331301595e-02, -2.458314752619149279e-02, -4.252530480245884925e-02, 9.733043787604266084e-02, -6.217238566516904152e-02, 3.767656091618994812e-02, 6.674680725588777973e-03, 4.245867422406505304e-02, -2.752200660186601699e-02, -8.318636634138946995e-03, -2.738884420387305285e-02, 1.785195524121836741e-02, -3.151218435289559073e-03, -3.927864338604547816e-04, 3.302976830190196104e-04, 1.387198082848713948e-06, 1.729085429046553641e-07, -1.454003656243721975e-07, -4.056191292896940703e-05, -5.055875832506090064e-06, 4.251531950061960394e-06, 7.087482338961141604e-02, -1.643445525800983908e-01, 2.668682182870234509e-01, 7.752581706917366366e-03, -2.674714571946596939e-02, 4.308263417785011123e-02, -9.385640612496094423e-03, 4.307848167667025635e-02, -6.910099104451945806e-02, -1.822493611414978121e-01, -4.510097387143227610e-02, 5.157836206906134952e-02, -1.170389534066011428e-01, -2.858136680923874240e-02, 3.256883555835647648e-02, 1.336331160725280354e-01, 3.257484898923947853e-02, -3.710113093740719653e-02, 3.343993600586595179e-03, 4.168150663620683060e-04, -3.505035785317401481e-04, -4.312491363797464269e-03, -5.375343342977005178e-04, 4.520175083867039156e-04, -5.045304632809267465e-04, -6.288764981405317546e-05, 5.288279643454484632e-05, 2.176577726533836937e-02, -1.041710664445027849e-02, -1.802940684978692962e-02, -3.097121964369356495e-02, 1.077096511204005125e-02, 2.079488766754130843e-02, -1.120464690158002596e-01, 4.736950869652114399e-02, 8.530900293808066359e-02, 3.029112757823893692e-02, 1.058529311156591879e-01, -6.894903720238335088e-02, -5.089618157121258979e-02, -6.973511953466600410e-02, 4.618114280030299196e-02, 1.143309394598741001e-02, 2.319568285212985151e-02, -1.522637168466081138e-02, -1.535733649675188493e-03, -1.914228911776438445e-04, 1.609692493993826663e-04, -2.603290366421702733e-03, -3.244894507721100851e-04, 2.728661290583660171e-04, 6.938458118266074663e-04, 8.648503036932213837e-05, -7.272604826511198082e-05, -2.609239945314979423e-02, 1.142603664459106681e-02, -2.051406106454568487e-02, 5.779549344910496142e-03, -3.860615030463052100e-02, 6.168332781226748551e-02, 2.068839156841529789e-02, -7.643723474881176927e-02, 1.229844977392647865e-01, -3.554667688747349674e-02, -8.262665730398828859e-03, 9.285295046969522723e-03, 1.497274901467501862e-01, 3.666859638982037511e-02, -4.181688913175674732e-02, -3.257377626487627069e-03, -8.171909213273372040e-04, 9.379633299917983094e-04, 5.408910405506226968e-04, 6.741984641424190365e-05, -5.669396175743082354e-05, 4.696290607396237790e-04, 5.853733334998140626e-05, -4.922457577157541143e-05, -5.350269144276139158e-03, -6.668890718077903363e-04, 5.607930831110977251e-04, 3.013271000130106694e-02, -1.241570117891089425e-02, -2.255430712666738058e-02, -1.643158253499693577e-02, 6.876116339617440766e-03, 1.242585434168311936e-02, 2.120265775977717496e-03, -2.988284987993197143e-03, -4.123302560925387432e-03, 3.528008965720315360e-02, -1.132921329184741026e-02, 6.435692645130823564e-03, -2.115291124444698342e-02, -2.971050496327276927e-02, 1.966236467455729359e-02, -2.194244461519655187e-02, -1.469000955331024871e-02, 1.000316933044766328e-02, -2.208576023807404254e-03, -2.752899293131040766e-04, 2.314938041951108548e-04, -5.840262773118632192e-04, -7.279647649213021596e-05, 6.121521886838239123e-05, -1.263538670848133802e-03, -1.574949051482092536e-04, 1.324388975109944740e-04, 8.955566031735841259e-03, -2.660296383100100095e-02, 4.296567375352825652e-02, 2.380373596470350059e-02, -7.784355459714024927e-02, 1.255004729498893912e-01, -1.824501349606120690e-02, 3.948761180940744964e-02, -6.423389834199008663e-02, 1.038606825469970407e-02, 2.616819816765628484e-03, -3.006960935423359793e-03, -1.864007491704058883e-02, -4.504736174636920880e-03, 5.118497771104377897e-03, 1.680266347982039554e-01, 4.105963063126880086e-02, -4.679634408112137711e-02, 3.343993600586595179e-03, 4.168150663620683060e-04, -3.505035785317401481e-04, -4.312491363797464269e-03, -5.375343342977005178e-04, 4.520175083867039156e-04, -5.045304632809267465e-04, -6.288764981405317546e-05, 5.288279643454484632e-05, 2.176577726533836937e-02, -1.041710664445027849e-02, -1.802940684978692962e-02, -3.097121964369356495e-02, 1.077096511204005125e-02, 2.079488766754130843e-02, -1.120464690158002596e-01, 4.736950869652114399e-02, 8.530900293808066359e-02, 3.029112757823893692e-02, 1.058529311156591879e-01, -6.894903720238335088e-02, -5.089618157121258979e-02, -6.973511953466600410e-02, 4.618114280030299196e-02, 1.143309394598741001e-02, 2.319568285212985151e-02, -1.522637168466081138e-02, -1.535733649675188493e-03, -1.914228911776438445e-04, 1.609692493993826663e-04, -2.603290366421702733e-03, -3.244894507721100851e-04, 2.728661290583660171e-04, 6.938458118266074663e-04, 8.648503036932213837e-05, -7.272604826511198082e-05, -2.609239945314979423e-02, 1.142603664459106681e-02, -2.051406106454568487e-02, 5.779549344910496142e-03, -3.860615030463052100e-02, 6.168332781226748551e-02, 2.068839156841529789e-02, -7.643723474881176927e-02, 1.229844977392647865e-01, -3.554667688747349674e-02, -8.262665730398828859e-03, 9.285295046969522723e-03, 1.497274901467501862e-01, 3.666859638982037511e-02, -4.181688913175674732e-02, -3.257377626487627069e-03, -8.171909213273372040e-04, 9.379633299917983094e-04, 1.097257666720985849e-03, 1.367686610077148478e-04, -1.150100103928514269e-04, -3.252401295559594844e-03, -4.053984617694676175e-04, 3.409032519425078027e-04, -1.217154259382106555e-04, -1.517132787898375553e-05, 1.275770753460001047e-05, -1.104423096905816498e-01, 4.615651100464009809e-02, 8.344619780982527601e-02, -1.998235369855275168e-01, 8.508819942125579738e-02, 1.528709647298205909e-01, 8.333302476347614896e-02, -3.488524142655123617e-02, -6.303339769808283255e-02, -7.468341447282240975e-02, -1.443673498458480642e-01, 9.485360739696327426e-02, -2.685004652445167612e-04, -1.702408228533323561e-02, 1.097613894113106531e-02, 9.496752299747332482e-02, 1.714581306702349373e-01, -1.128066531362114239e-01, -2.109671824413435984e-03, -2.629619271223545066e-04, 2.211270750801623281e-04, 1.011694656468142307e-02, 1.261035832424879221e-03, -1.060416495448196581e-03, 2.326027531269699879e-04, 2.899297772687444119e-05, -2.438045854305356789e-05, -9.775618976121780001e-04, 7.897148922927013995e-03, -1.259878571596698138e-02, -5.534571406250721713e-03, 2.552681480358522451e-02, -4.094434810336724379e-02, -1.258721457759937913e-02, 4.161890111720080443e-02, -6.708566706120022705e-02, 3.521744971093632853e-02, 8.557787631933998912e-03, -9.738493960065902622e-03, -8.446926488038911107e-02, -2.017604402799078392e-02, 2.285024948138817888e-02, -9.755577915095828626e-03, -2.364722966186930900e-03, 2.689144780896026744e-03, 8.392348196279006065e-05, 1.046071729847805219e-05, -8.796512273720217211e-06, -2.967282659264359589e-03, -3.698595949224694123e-04, 3.110182957302592738e-04, -1.688223115474902841e-03, -2.104300767164184042e-04, 1.769525645115341121e-04, -1.040849854787611189e-01, 4.406117175034113265e-02, 7.931633477513304331e-02, 3.539829580561168476e-02, -1.443144702217136026e-02, -2.631106338063535569e-02, -4.383990895980735547e-02, 1.895493123709470276e-02, 3.388325869579450478e-02, 1.809448338386955915e-02, 4.269882582195522885e-02, -2.795653019460052346e-02, 4.363124777259473619e-02, 8.597058258914810902e-02, -5.646456449126337207e-02, 4.431189331687027805e-02, 7.186269332716928304e-02, -4.739074421553418626e-02, 7.807665162715203382e-05, 9.731933913865978996e-06, -8.183671700296416994e-06, 2.525821455836478949e-03, 3.148332692827336839e-04, -2.647461582604813284e-04, 5.088778918832323993e-03, 6.342953893162101269e-04, -5.333847591977234877e-04, 1.765533347871811772e-03, -1.422682766506909793e-02, 2.269730547460076936e-02, 2.888222424864686153e-04, -4.083171371247279469e-03, 6.494062010930001794e-03, 1.594130471018519873e-02, -4.922350239779287734e-02, 7.944117864515577720e-02, -5.516443865142822006e-02, -1.340804559261108905e-02, 1.525892700429632917e-02, 7.450140187529649682e-02, 1.809617933997387934e-02, -2.059052256811338619e-02, -3.118940445306414219e-02, -7.412336287839308216e-03, 8.382871287998559101e-03, 5.408910405506207452e-04, 6.741984641424155129e-05, -5.669396175743063380e-05, 4.696290607396231285e-04, 5.853733334998132494e-05, -4.922457577157534367e-05, -5.350269144276134821e-03, -6.668890718077897942e-04, 5.607930831110975083e-04, 3.013271000130106694e-02, -1.241570117891090119e-02, -2.255430712666738752e-02, -1.643158253499694271e-02, 6.876116339617444236e-03, 1.242585434168312457e-02, 2.120265775977718363e-03, -2.988284987993198010e-03, -4.123302560925387432e-03, 3.528008965720314666e-02, -1.132921329184741026e-02, 6.435692645130823564e-03, -2.115291124444698342e-02, -2.971050496327276927e-02, 1.966236467455729012e-02, -2.194244461519655881e-02, -1.469000955331024871e-02, 1.000316933044766501e-02, -2.208576023807403820e-03, -2.752899293131040766e-04, 2.314938041951108548e-04, -5.840262773118632192e-04, -7.279647649213021596e-05, 6.121521886838239123e-05, -1.263538670848133802e-03, -1.574949051482092536e-04, 1.324388975109944740e-04, 8.955566031735841259e-03, -2.660296383100100095e-02, 4.296567375352825652e-02, 2.380373596470350059e-02, -7.784355459714024927e-02, 1.255004729498893912e-01, -1.824501349606121037e-02, 3.948761180940744964e-02, -6.423389834199008663e-02, 1.038606825469969019e-02, 2.616819816765625015e-03, -3.006960935423356324e-03, -1.864007491704059577e-02, -4.504736174636922615e-03, 5.118497771104379632e-03, 1.680266347982039554e-01, 4.105963063126880086e-02, -4.679634408112137711e-02, 8.392348196278930170e-05, 1.046071729847797087e-05, -8.796512273720142672e-06, -2.967282659264356987e-03, -3.698595949224691413e-04, 3.110182957302590027e-04, -1.688223115474903708e-03, -2.104300767164184855e-04, 1.769525645115341934e-04, -1.040849854787611189e-01, 4.406117175034113265e-02, 7.931633477513304331e-02, 3.539829580561167782e-02, -1.443144702217136026e-02, -2.631106338063535569e-02, -4.383990895980735547e-02, 1.895493123709470276e-02, 3.388325869579450478e-02, 1.809448338386955221e-02, 4.269882582195521498e-02, -2.795653019460051653e-02, 4.363124777259472925e-02, 8.597058258914809514e-02, -5.646456449126335819e-02, 4.431189331687027111e-02, 7.186269332716926916e-02, -4.739074421553417932e-02, 7.807665162715246750e-05, 9.731933913866019654e-06, -8.183671700296457651e-06, 2.525821455836478515e-03, 3.148332692827336297e-04, -2.647461582604812742e-04, 5.088778918832324860e-03, 6.342953893162102353e-04, -5.333847591977235961e-04, 1.765533347871809603e-03, -1.422682766506909793e-02, 2.269730547460076589e-02, 2.888222424864694826e-04, -4.083171371247282938e-03, 6.494062010930008733e-03, 1.594130471018519873e-02, -4.922350239779287040e-02, 7.944117864515577720e-02, -5.516443865142821312e-02, -1.340804559261108558e-02, 1.525892700429632570e-02, 7.450140187529649682e-02, 1.809617933997387934e-02, -2.059052256811338966e-02, -3.118940445306412831e-02, -7.412336287839304746e-03, 8.382871287998553897e-03, -9.575909105642434974e-04, -1.193597735547498307e-04, 1.003707186710399045e-04, -9.520061199010912585e-05, -1.186636523389461756e-05, 9.978534401229592523e-06, -5.876800709203859434e-03, -7.325190685693192200e-04, 6.159819440242017292e-04, -1.659431774532551043e-02, 6.520628417529478540e-03, 1.204087494393247214e-02, 6.518824051016284399e-03, -2.745500204548994606e-03, -4.950724849051978994e-03, -5.340810191179472081e-03, 3.101366677982481286e-03, 5.077959020099345744e-03, 7.727976016970144156e-03, 7.022558645366243878e-03, -4.714356496325102820e-03, 7.018017321145150929e-03, 1.341962078953426278e-02, -8.818944869050635710e-03, -2.755773236988961865e-03, 1.079245666846929096e-02, -6.886663303228377636e-03, 9.801230913130992879e-04, 1.221683173308112048e-04, -1.027324486645460452e-04, 1.233918620327190629e-04, 1.538028875195364422e-05, -1.293342463232469071e-05, 4.892751025155074075e-03, 6.098613175830685205e-04, -5.128379261493998297e-04, -7.792305682365031905e-03, 2.541307371885552502e-02, -4.097328323558844382e-02, 2.530143617608526449e-02, -8.265149730513186854e-02, 1.332544508945474881e-01, -1.184335640259520997e-02, 3.220055758982264676e-02, -5.209911236104310117e-02, 8.090761694886683397e-02, 1.959431243541279177e-02, -2.227702786419644143e-02, 1.968691296265078980e-02, 4.764576998712748319e-03, -5.415896903683155988e-03, 1.534638141861073557e-01, 3.728680895816388619e-02, -4.242975875503233324e-02 + }; + std::vector expected_gt; + std::vector expected_gv; + int natoms = 6; + int nsel = 2; + int odim; + deepmd::DeepTensor dp; + + void SetUp() override { + std::string file_name = "../../tests/infer/deeppolar_new.pbtxt"; + int fd = open(file_name.c_str(), O_RDONLY); + tensorflow::protobuf::io::ZeroCopyInputStream* input = new tensorflow::protobuf::io::FileInputStream(fd); + tensorflow::GraphDef graph_def; + tensorflow::protobuf::TextFormat::Parse(input, &graph_def); + delete input; + std::fstream output("deeppolar_new.pb", std::ios::out | std::ios::trunc | std::ios::binary); + graph_def.SerializeToOstream(&output); + // check the string by the following commands + // string txt; + // tensorflow::protobuf::TextFormat::PrintToString(graph_def, &txt); + dp.init("deeppolar_new.pb"); + odim = dp.output_dim (); + + expected_gt.resize(odim); + for(int ii = 0; ii < nsel; ++ii){ + for(int dd = 0; dd < odim; ++dd){ + expected_gt[dd] += expected_t[ii*odim+dd]; + } + } + + expected_gv.resize(odim * 9); + for (int kk = 0; kk < odim; ++kk){ + for(int ii = 0; ii < natoms; ++ii){ + for(int dd = 0; dd < 9; ++dd){ + expected_gv[kk*9 + dd] += expected_v[kk*natoms*9 + ii*9 + dd]; + } + } + } + }; + + void TearDown() override { + remove( "deeppolar_new.pb" ) ; + }; +}; + + +TEST_F(TestInferDeepPolarNew, cpu_build_nlist) +{ + EXPECT_EQ(dp.cutoff(), 6.); + EXPECT_EQ(dp.numb_types(), 2); + EXPECT_EQ(dp.output_dim(), 9); + std::vector sel_types = dp.sel_types(); + EXPECT_EQ(sel_types.size(), 1); + EXPECT_EQ(sel_types[0], 0); + + std::vector gt, ff, vv, at, av; + + dp.compute(at, coord, atype, box); + EXPECT_EQ(at.size(), expected_t.size()); + for(int ii = 0; ii < expected_t.size(); ++ii){ + EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + } + + dp.compute(gt, ff, vv, coord, atype, box); + EXPECT_EQ(gt.size(), expected_gt.size()); + for(int ii = 0; ii < expected_gt.size(); ++ii){ + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + } + EXPECT_EQ(ff.size(), expected_f.size()); + for(int ii = 0; ii < expected_f.size(); ++ii){ + EXPECT_LT(fabs(ff[ii] - expected_f[ii]), 1e-10); + } + EXPECT_EQ(vv.size(), expected_gv.size()); + for(int ii = 0; ii < expected_gv.size(); ++ii){ + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + } + + dp.compute(gt, ff, vv, at, av, coord, atype, box); + EXPECT_EQ(gt.size(), expected_gt.size()); + for(int ii = 0; ii < expected_gt.size(); ++ii){ + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + } + EXPECT_EQ(ff.size(), expected_f.size()); + for(int ii = 0; ii < expected_f.size(); ++ii){ + EXPECT_LT(fabs(ff[ii] - expected_f[ii]), 1e-10); + } + EXPECT_EQ(vv.size(), expected_gv.size()); + for(int ii = 0; ii < expected_gv.size(); ++ii){ + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + } + EXPECT_EQ(at.size(), expected_t.size()); + for(int ii = 0; ii < expected_t.size(); ++ii){ + EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + } + EXPECT_EQ(av.size(), expected_v.size()); + for(int ii = 0; ii < expected_v.size(); ++ii){ + EXPECT_LT(fabs(av[ii] - expected_v[ii]), 1e-10); + } +} + + +TEST_F(TestInferDeepPolarNew, cpu_lmp_nlist) +{ + float rc = dp.cutoff(); + int nloc = coord.size() / 3; + std::vector coord_cpy; + std::vector atype_cpy, mapping; + std::vector ilist(nloc), numneigh(nloc); + std::vector firstneigh(nloc); + std::vector > nlist_data; + deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]); + _build_nlist(nlist_data, coord_cpy, atype_cpy, mapping, + coord, atype, box, rc); + int nall = coord_cpy.size() / 3; + convert_nlist(inlist, nlist_data); + + std::vector gt, ff, vv, at, av; + + dp.compute(at, coord_cpy, atype_cpy, box, nall-nloc, inlist); + + EXPECT_EQ(at.size(), expected_t.size()); + for(int ii = 0; ii < expected_t.size(); ++ii){ + EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + } + + + dp.compute(gt, ff, vv, coord_cpy, atype_cpy, box, nall-nloc, inlist); + + EXPECT_EQ(gt.size(), expected_gt.size()); + for(int ii = 0; ii < expected_gt.size(); ++ii){ + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + } + // remove ghost atoms + std::vector rff (odim * nloc * 3); + for(int kk = 0; kk < odim; ++kk){ + _fold_back(rff.begin() + kk * nloc * 3, ff.begin() + kk * nall * 3, mapping, nloc, nall, 3); + } + EXPECT_EQ(rff.size(), expected_f.size()); + for(int ii = 0; ii < expected_f.size(); ++ii){ + EXPECT_LT(fabs(rff[ii] - expected_f[ii]), 1e-10); + } + // virial + EXPECT_EQ(vv.size(), expected_gv.size()); + for(int ii = 0; ii < expected_gv.size(); ++ii){ + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + } + + + dp.compute(gt, ff, vv, at, av, coord_cpy, atype_cpy, box, nall-nloc, inlist); + + EXPECT_EQ(gt.size(), expected_gt.size()); + for(int ii = 0; ii < expected_gt.size(); ++ii){ + EXPECT_LT(fabs(gt[ii] - expected_gt[ii]), 1e-10); + } + // remove ghost atoms + for(int kk = 0; kk < odim; ++kk){ + _fold_back(rff.begin() + kk * nloc * 3, ff.begin() + kk * nall * 3, mapping, nloc, nall, 3); + } + EXPECT_EQ(rff.size(), expected_f.size()); + for(int ii = 0; ii < expected_f.size(); ++ii){ + EXPECT_LT(fabs(rff[ii] - expected_f[ii]), 1e-10); + } + // virial + EXPECT_EQ(vv.size(), expected_gv.size()); + for(int ii = 0; ii < expected_gv.size(); ++ii){ + EXPECT_LT(fabs(vv[ii] - expected_gv[ii]), 1e-10); + } + // atom tensor + EXPECT_EQ(at.size(), expected_t.size()); + for(int ii = 0; ii < expected_t.size(); ++ii){ + EXPECT_LT(fabs(at[ii] - expected_t[ii]), 1e-10); + } + // atom virial + std::vector rav (odim * nloc * 9); + for(int kk = 0; kk < odim; ++kk){ + _fold_back(rav.begin() + kk * nloc * 9, av.begin() + kk * nall * 9, mapping, nloc, nall, 9); + } + EXPECT_EQ(rav.size(), expected_v.size()); + for(int ii = 0; ii < expected_v.size(); ++ii){ + EXPECT_LT(fabs(rav[ii] - expected_v[ii]), 1e-10); + } +} + diff --git a/source/api_cc/tests/test_dipolecharge.cc b/source/api_cc/tests/test_dipolecharge.cc index b13c3c7d7a..6db7b8af0e 100644 --- a/source/api_cc/tests/test_dipolecharge.cc +++ b/source/api_cc/tests/test_dipolecharge.cc @@ -133,8 +133,9 @@ TEST_F(TestDipoleCharge, cpu_lmp_nlist) int sel_nloc = sel_nall - sel_nghost; std::vector sel_atype(sel_bwd.size()); deepmd::select_map(sel_atype, atype, sel_fwd, 1); - deepmd::AtomMap nnp_map(sel_atype.begin(), sel_atype.begin() + sel_nloc); - const std::vector & sort_fwd_map(nnp_map.get_fwd_map()); + // Yixiao: because the deeptensor already return the correct order, the following map is no longer needed + // deepmd::AtomMap nnp_map(sel_atype.begin(), sel_atype.begin() + sel_nloc); + // const std::vector & sort_fwd_map(nnp_map.get_fwd_map()); // // add coords std::vector add_coord; @@ -142,7 +143,9 @@ TEST_F(TestDipoleCharge, cpu_lmp_nlist) std::vector> pairs; for(int ii = 0; ii < nloc; ++ii){ if(_in_vec(atype[ii], sel_types)){ - int res_idx = sort_fwd_map[sel_fwd[ii]]; + // Yixiao: the sort map is no longer needed + // int res_idx = sort_fwd_map[sel_fwd[ii]]; + int res_idx = sel_fwd[ii]; std::vector tmp_coord(3); for(int dd = 0; dd < 3; ++dd){ tmp_coord[dd] = coord[ii*3+dd] + dipole[res_idx*3+dd]; diff --git a/source/api_cc/tests/test_utils.h b/source/api_cc/tests/test_utils.h index e6a496e374..d2d9d6c261 100644 --- a/source/api_cc/tests/test_utils.h +++ b/source/api_cc/tests/test_utils.h @@ -3,24 +3,37 @@ inline void _fold_back( - std::vector &out, - const std::vector &in, + typename std::vector::iterator out, + const typename std::vector::const_iterator in, const std::vector &mapping, const int nloc, const int nall, const int ndim) { - out.resize(nloc*ndim); - std::copy(in.begin(), in.begin() + nloc*ndim, out.begin()); + // out.resize(nloc*ndim); + std::copy(in, in + nloc*ndim, out); for(int ii = nloc; ii < nall; ++ii){ int in_idx = ii; int out_idx = mapping[in_idx]; for(int dd = 0; dd < ndim; ++dd){ - out[out_idx * ndim + dd] += in[in_idx * ndim + dd]; + *(out + out_idx * ndim + dd) += *(in + in_idx * ndim + dd); } } } +inline void +_fold_back( + std::vector &out, + const std::vector &in, + const std::vector &mapping, + const int nloc, + const int nall, + const int ndim) +{ + out.resize(nloc*ndim); + _fold_back(out.begin(), in.begin(), mapping, nloc, nall, ndim); +} + inline void _build_nlist( std::vector> &nlist_data, diff --git a/source/install/test_cc_local.sh b/source/install/test_cc_local.sh index 1f28d7efa8..71d6954d46 100755 --- a/source/install/test_cc_local.sh +++ b/source/install/test_cc_local.sh @@ -23,7 +23,6 @@ echo "try to find tensorflow in ${tensorflow_root}" BUILD_TMP_DIR=${SCRIPT_PATH}/../build_cc_tests INSTALL_PREFIX=${SCRIPT_PATH}/../../dp mkdir -p ${BUILD_TMP_DIR} -mkdir -p ${INSTALL_PREFIX} cd ${BUILD_TMP_DIR} cmake -DINSTALL_TENSORFLOW=FALSE -DTENSORFLOW_ROOT=${tensorflow_root} ../api_cc/tests make -j${NPROC} diff --git a/source/lib/src/cuda/CMakeLists.txt b/source/lib/src/cuda/CMakeLists.txt index 7ef9839290..71afbee9b6 100644 --- a/source/lib/src/cuda/CMakeLists.txt +++ b/source/lib/src/cuda/CMakeLists.txt @@ -105,7 +105,7 @@ endif() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -DCUB_IGNORE_DEPRECATED_CPP_DIALECT -DCUB_IGNORE_DEPRECATED_CPP_DIALECT") -if (${CUDA_VERSION_MAJOR} LESS_EQUAL "10") +if (${CUDA_VERSION_MAJOR} LESS_EQUAL "11") # check unsupported -std=c++17 set(CMAKE_CXX_FLAGS_LIST "${CMAKE_CXX_FLAGS}") separate_arguments(CMAKE_CXX_FLAGS_LIST) diff --git a/source/lmp/fix_dplr.cpp b/source/lmp/fix_dplr.cpp index 5ce85490fc..fc633190ec 100644 --- a/source/lmp/fix_dplr.cpp +++ b/source/lmp/fix_dplr.cpp @@ -305,8 +305,9 @@ void FixDPLR::pre_force(int vflag) vector sel_type(sel_bwd.size()); deepmd::select_map(sel_type, dtype, sel_fwd, 1); - deepmd::AtomMap atom_map(sel_type.begin(), sel_type.begin() + sel_nloc); - const vector & sort_fwd_map(atom_map.get_fwd_map()); + // Yixiao: because the deeptensor already return the correct order, the following map is no longer needed + // deepmd::AtomMap atom_map(sel_type.begin(), sel_type.begin() + sel_nloc); + // const vector & sort_fwd_map(atom_map.get_fwd_map()); vector > valid_pairs; get_valid_pairs(valid_pairs); @@ -318,8 +319,10 @@ void FixDPLR::pre_force(int vflag) for (int ii = 0; ii < valid_pairs.size(); ++ii){ int idx0 = valid_pairs[ii].first; int idx1 = valid_pairs[ii].second; - assert(idx0 < sel_fwd.size() && sel_fwd[idx0] < sort_fwd_map.size()); - int res_idx = sort_fwd_map[sel_fwd[idx0]]; + assert(idx0 < sel_fwd.size()); // && sel_fwd[idx0] < sort_fwd_map.size()); + // Yixiao: the sort map is no longer needed + // int res_idx = sort_fwd_map[sel_fwd[idx0]]; + int res_idx = sel_fwd[idx0]; // int ret_idx = dpl_bwd[res_idx]; for (int dd = 0; dd < 3; ++dd){ x[idx1][dd] = x[idx0][dd] + tensor[res_idx * 3 + dd]; diff --git a/source/tests/common.py b/source/tests/common.py index 3bde871077..5a63666825 100644 --- a/source/tests/common.py +++ b/source/tests/common.py @@ -359,3 +359,24 @@ def virial_dw_test (inter, ana_v = dw_0[ii] testCase.assertAlmostEqual(num_v, ana_v, places = places) + +def finite_difference(f, x, delta=1e-6): + in_shape = x.shape + y0 = f(x) + out_shape = y0.shape + res = np.empty(out_shape+in_shape) + for idx in np.ndindex(*in_shape): + diff = np.zeros(in_shape) + diff[idx] += delta + y1p = f(x+diff) + y1n = f(x-diff) + res[(Ellipsis, *idx)] = (y1p - y1n) / (2 * delta) + return res + + +def strerch_box(old_coord, old_box, new_box): + ocoord = old_coord.reshape(-1,3) + obox = old_box.reshape(3,3) + nbox = new_box.reshape(3,3) + ncoord = ocoord @ np.linalg.inv(obox) @ nbox + return ncoord.reshape(old_coord.shape) \ No newline at end of file diff --git a/source/tests/infer/deepdipole_fake.pbtxt b/source/tests/infer/deepdipole_fake.pbtxt new file mode 100644 index 0000000000..5b41d69f20 --- /dev/null +++ b/source/tests/infer/deepdipole_fake.pbtxt @@ -0,0 +1,61543 @@ +node { + name: "t_box" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "t_coord" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "t_type" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "t_natoms" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 4 + } + } + } + } +} +node { + name: "t_mesh" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "model_attr/tmap" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "O H" + } + } + } +} +node { + name: "model_attr/sel_type" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\000\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "model_attr/model_type" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "dipole" + } + } + } +} +node { + name: "model_attr/model_version" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "1.0" + } + } + } +} +node { + name: "model_attr/output_dim" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "add/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "add" + op: "AddV2" + input: "add/x" + input: "strided_slice" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 4 + } + } + } +} +node { + name: "strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_1" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "add_1" + op: "AddV2" + input: "add" + input: "strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "descrpt_attr/rcut" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 2.0 + } + } + } +} +node { + name: "descrpt_attr/ntypes" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "descrpt_attr/ndescrpt" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "descrpt_attr/sel" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\005\000\000\000\n\000\000\000" + } + } + } +} +node { + name: "descrpt_attr/t_avg" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 2 + } + dim { + size: 60 + } + } + tensor_content: "\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\357/Y\216\343\322\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G~\236\244\027)\300?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "descrpt_attr/t_avg/read" + op: "Identity" + input: "descrpt_attr/t_avg" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@descrpt_attr/t_avg" + } + } + } +} +node { + name: "descrpt_attr/t_std" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 2 + } + dim { + size: 60 + } + } + tensor_content: "Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?Xx\310\027*\235\326?c\233\033\304\037\273\314?c\233\033\304\037\273\314?c\233\033\304\037\273\314?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\363zI\304\372\361\322?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?\235\033\316\332\036\307\307?" + } + } + } +} +node { + name: "descrpt_attr/t_std/read" + op: "Identity" + input: "descrpt_attr/t_std" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@descrpt_attr/t_std" + } + } + } +} +node { + name: "strided_slice_2/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_2/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_2/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_2" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul" + op: "Mul" + input: "strided_slice_2" + input: "mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape/shape" + op: "Pack" + input: "Reshape/shape/0" + input: "mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape" + op: "Reshape" + input: "t_coord" + input: "Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_1/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\t\000\000\000" + } + } + } +} +node { + name: "Reshape_1" + op: "Reshape" + input: "t_box" + input: "Reshape_1/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_3/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_3/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_3/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_3" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Reshape_2/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_2/shape" + op: "Pack" + input: "Reshape_2/shape/0" + input: "strided_slice_3" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_2" + op: "Reshape" + input: "t_type" + input: "Reshape_2/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdEnvMatA" + op: "ProdEnvMatA" + input: "Reshape" + input: "Reshape_2" + input: "t_natoms" + input: "Reshape_1" + input: "t_mesh" + input: "descrpt_attr/t_avg/read" + input: "descrpt_attr/t_std/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "rcut_a" + value { + f: -1.0 + } + } + attr { + key: "rcut_r" + value { + f: 2.0 + } + } + attr { + key: "rcut_r_smth" + value { + f: 1.7999999523162842 + } + } + attr { + key: "sel_a" + value { + list { + i: 5 + i: 10 + } + } + } + attr { + key: "sel_r" + value { + list { + i: 0 + i: 0 + } + } + } +} +node { + name: "Reshape_3/shape" + op: "Const" + 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<\000\000\000" + } + } + } +} +node { + name: "Reshape_3" + op: "Reshape" + input: "ProdEnvMatA" + input: "Reshape_3/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "o_rmat" + op: "Identity" + input: "Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "o_rmat_deriv" + op: "Identity" + input: "ProdEnvMatA:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "o_rij" + op: "Identity" + input: "ProdEnvMatA:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "o_nlist" + op: "Identity" + input: "ProdEnvMatA:3" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_4/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_4/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_4/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_4" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_1/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_1" + op: "Mul" + input: "mul_1/x" + input: "strided_slice_4" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_4/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_4/shape" + op: "Pack" + input: "Reshape_4/shape/0" + input: "mul_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_4" + op: "Reshape" + input: "o_rmat" + input: "Reshape_4/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_5/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_5/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_5/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_5" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_2/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_2" + op: "Mul" + input: "strided_slice_5" + input: "mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Slice/begin" + op: "Const" + 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: "Slice/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice/size" + op: "Pack" + input: "Slice/size/0" + input: "mul_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice" + op: "Slice" + input: "Reshape_4" + input: "Slice/begin" + input: "Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_5/shape" + op: "Const" + 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<\000\000\000" + } + } + } +} +node { + name: "Reshape_5" + op: "Reshape" + input: "Slice" + input: "Reshape_5/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Slice/begin" + op: "Const" + 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: "filter_type_0/Slice/size" + op: "Const" + 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\024\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice" + op: "Slice" + input: "Reshape_5" + input: "filter_type_0/Slice/begin" + input: "filter_type_0/Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape/shape" + op: "Const" + 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\004\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape" + op: "Reshape" + input: "filter_type_0/Slice" + input: "filter_type_0/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Slice_1/begin" + op: "Const" + 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: "filter_type_0/Slice_1/size" + op: "Const" + 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: "filter_type_0/Slice_1" + op: "Slice" + input: "filter_type_0/Reshape" + input: "filter_type_0/Slice_1/begin" + input: "filter_type_0/Slice_1/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_1/shape" + op: "Const" + 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: "filter_type_0/Reshape_1" + op: "Reshape" + input: "filter_type_0/Slice_1" + input: "filter_type_0/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/matrix_1_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\260\344\3570\344:\244?\231\326*\214HK\333?\0373\231(\214\263\337\277!R\355\030\331@\270?O7!\356\361\272\322?\315\3259\253\327r\314\277\203\212\017,\372\214\327?\343U\313\032Ux\305?\357)<\370\014M\321\277\320\270Y\370$\266\262\277" + } + } + } +} +node { + name: "filter_type_0/matrix_1_0/read" + op: "Identity" + input: "filter_type_0/matrix_1_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_1_0" + } + } + } +} +node { + name: "filter_type_0/bias_1_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\221\205\244\342b$\341\277\n5\320\376>\267\001\300\214\33510\tb\350\277\033+\207HA\033\335\277\020\021\026\261|\314\360\277~X\275\213\004\321\377\277\340\320\203\226\242\267\351\277\215\344Q\262\027\212\364?/\032\340?/\016j\275Ci\311?\353H\024\251\314\311\331?-\301\346*\257\016\343?r\032p\332\334P\277\277\270\\\016\246}\235\265\277\347M\033;\342e\273\277,m3<\271\351\311\277\331E\252\255\252b\333?\277UbM\006\317\323\277\375\226\261B\350\312\305?KW\225t\3642\245\277l^\304>\363\037\300\277p\006E\332r>\317?\346\327k\240+^\310?\375\276\301R\223\223\305?%\252\321\031$u\331\277\377\t\237DU\231\253\277\241\334:\302\350\373\326?\024\n\260\312$\374\330?hAk\353NN\212?\302\336\022\026%\223\334?\003f\350\273TY\300\277\001\336\005 T\367\303\277}(\24671\317\223?\204\267\257\0032N\301\277\211\250\330L\r\245\230\277\205\033e\251j\257\341\277E0\025\037\214\314\226?\312M\213g6\250\301\27725\330D\214\361\267?\035\322^\270\323x\305\277\355L\266+\000\007\265?\266\2603\264S\216\242?.\033\247\362-S\325?\nM\246\213$\313\320\277\034\355\356\372R\035\273\277\311\372\226J\014j\320\277\030[\242~-i\320\277z\337\016\025\304\275\271\277\256\371\272v\276\256\306?\005vO\307\356l\273?7\220\227\022\037)\326\277\024\205\017\001\347\216\300\277\320\373\301\234?\301\267?\324O\220\347\246\253\232?\t\021\177%[\252\265?IDD\034\241+\300\277E!zd\004\367\310?@)\314:\254\205\227?*\202)\345\236\313\302?W\210\026\212u\342\227?gC\\\315\240:\212\277\331\366\362\236\036e\324\277\024\256\337L\260\240\304?\001\300w\234K\231\312?\274\345\376R!\306\275?\216l\263`\357\261\320\277\335A\276\233$\036\305?Yi\331\233\353=\314?\207\316\201~U\316\305?\306\336\360\211\342:\267?\016(\227\366\370ej?\203\377\332\231|\211\300?\303,g\\F\220\314?\037\024w\221U`\335\277p0\000_\030\223\321\277\347\r\257\'\347\343\264?\200\273z\340\305j\327?\366\210\034\203\263\305\222\277\377`\303*\314,\261\277\234\341\002\263\361\365\313?!\225\003\013\212#\337\277\004A\344\205\207k\342?\275B\337\036\207\005\303?\325\317o7\244\005\312\277)\234\355}\342W\253\2770\363\341\314\355x\310\277\r\nK\2261\232\270?23\211\345\216\023\234?W\371 \276;\232\325?O\244\010\330Oc\325\277\t{@\257K\021\266\277V\022r\354\315\376\343\277\327}\016\351y|\323\277\nd/\206\273\356\261?v\354C\240\303\212\306\277\035\204(\323!\305\336\277N\345\020n\311\267\277?P\3612\231\230\275\341\277" + } + } + } +} +node { + name: "filter_type_0/matrix_2_0/read" + op: "Identity" + input: "filter_type_0/matrix_2_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_2_0" + } + } + } +} +node { + name: "filter_type_0/bias_2_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: ",\274!\205w\250\367\277W\333~\303\001\310\355\277qM\300\270\337@\317?:\3277\024\362\217\330\277kc\331\366\362\200\363\277YwYl@0\341?\307\375y\32018\323?\316UD\204\360\332\360?mtx\265\307[\375?\356\243\355/\221(\355\277" + } + } + } +} +node { + name: "filter_type_0/bias_2_0/read" + op: "Identity" + input: "filter_type_0/bias_2_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_2_0" + } + } + } +} +node { + name: "filter_type_0/MatMul_1" + op: "MatMul" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_1" + op: "AddV2" + input: "filter_type_0/MatMul_1" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_1" + op: "Tanh" + input: "filter_type_0/add_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_3/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_3" + op: "Reshape" + input: "filter_type_0/Tanh_1" + input: "filter_type_0/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/add_2" + op: "AddV2" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/matrix_3_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\006\216\003\230\301\216\333?\222\204\300\354\342/\272\277\247\253\311%\322x\301?\252\361:\350\234M\344?\247n$\311\000\001\276?H\037\303p\303\250\267?f\\P\275_>\337?\375QDOW\355\315\277\226Wr\r\244\266\263\277\341y\2223\312\246\324\277\305\370\024\337\274\233\326?M\374\307\274\324\n\303?]\t\317{\347&\263\277\005J\0023}`\321\277\251\004c\305>\353\321?\351\271wk\205\315\301\277\214\365q\342\3702\340?!81\332\343s\301\277z\361\311@\325\t\327?\246\351aS|\254\224\277ILJw\345}\316?\253\343\'}\312\225\341?o\334\0260\345z\306?z\374_\254\2331\323?\020\002^\350\'\220\306\277\247:\263]\354/\230\277\263\022\003d\ro\305?\005\241\302\261.\322\312?\250\255\254\324\323\326\303?a\253\316O\037f\325\277e\356\223=\377\326\313\277\2150\356\204\\\036\313\277\035\025\252\243\3477\336?R.\344\256i\272\331?\252g\n\326\3000g?\240\347B\007\242\n\327\277\'\3467@,\232\266?q\337\t;R\346\324\277\225\n\211%\037j\307?+o,\223}\343\304??$\274\325tM\320\277\255\342\216\200G\004\343\277\342\334\020\225\227\231\242\277\372\rD\017.\013\263?}\244y\261P*\221\277\323\271\277H&\303\304\277\0022\351\375\201=\303?n>@|j6\341\2773\366\215E8\263\321?\212\036 \353\350^\326\277\320\027d\022\0264\230?}sM\030\306An?\336\300C\342\2231\324?zE\231f\332\207\313?W\344\241A\322\347\247\277\205\216N\013\253}\300\277\230\306\260nO\313\251\277\344\010:\267gS\300?\306\014\316V\003\366\277\277\312?\036\316F\316\266?W\346\350\216\314l\304?\351|\226\r\264\340\241?\3050\034\213\311N\303?\354V?\255\372k\321?\264Tz\n]\352\321\277\021\362\237\270\203X\272\277s\230G\357\332d\315\277\010%9\307\251f\326\277\350\374\377\370\347\250\322?\217\313\006N\232\367\307\277\204\221\270\216yn\324\277\272\252d\245F\205\312?\205\ne\013\351\360\325\277\000\325\376\236=:\324?\265\'\355\252\035\267\276\277z^\346v\310*\314?\327&e\t\021\317\331\277ei,\321\377\240\325?\255\345p\3460@\340\277\337\010\274`\177!\312?\341p\\W\025\254\270\277&2\244\302\301\330\300?\033\272\235\324\304\301\240?\236\254\2147\256\033\323\277\370\261\303\nH\306\334?\214>!\2407*\326\277e%\030*\212\354\321\277K\330\353\243\247]\324\2770\032\n\216\217\314\337\277\325\352~\2613\020\267?\227\314\255\235@\221\333?\254\003!\361\275\267\242?\236*O~|\356\276?\207{\265Z;\350\345?\307\034\274\002\310.\302?rW\274\334\364<\307\277\n>a\360G\306\327\277\301\016+\244\231`\243?\036\336.\r\313Q\276?&\236Q\245\360\227\273\277" + } + } + } +} +node { + name: "filter_type_0/matrix_3_0/read" + op: "Identity" + input: "filter_type_0/matrix_3_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_3_0" + } + } + } +} +node { + name: "filter_type_0/bias_3_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "SV\001\316\251\341\275?O#\233\212f\264\352?f\261:\242S\020\367?\035\374\361D\270\364\311?\234|?\004\035\007\375\277/\376\006u3\225\364?\305O\302-RS\370?\240t\001\013nH\341\277Y\2601\244f\264\331\277M\236\270\253\340\302\310\277" + } + } + } +} +node { + name: "filter_type_0/bias_3_0/read" + op: "Identity" + input: "filter_type_0/bias_3_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_3_0" + } + } + } +} +node { + name: "filter_type_0/MatMul_2" + op: "MatMul" + input: "filter_type_0/add_2" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_3" + op: "AddV2" + input: "filter_type_0/MatMul_2" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_2" + op: "Tanh" + input: "filter_type_0/add_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_4/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_4" + op: "Reshape" + input: "filter_type_0/Tanh_2" + input: "filter_type_0/Reshape_4/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/add_4" + op: "AddV2" + input: "filter_type_0/add_2" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_5/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\005\000\000\000\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_5" + op: "Reshape" + input: "filter_type_0/add_4" + input: "filter_type_0/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Reshape_6/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\005\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_6" + op: "Reshape" + input: "filter_type_0/Slice" + input: "filter_type_0/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/MatMul_3" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_0/Slice_2/begin" + op: "Const" + 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\024\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice_2/size" + op: "Const" + 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(\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice_2" + op: "Slice" + input: "Reshape_5" + input: "filter_type_0/Slice_2/begin" + input: "filter_type_0/Slice_2/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_7/shape" + op: "Const" + 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\004\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_7" + op: "Reshape" + input: "filter_type_0/Slice_2" + input: "filter_type_0/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Slice_3/begin" + op: "Const" + 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: "filter_type_0/Slice_3/size" + op: "Const" + 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: "filter_type_0/Slice_3" + op: "Slice" + input: "filter_type_0/Reshape_7" + input: "filter_type_0/Slice_3/begin" + input: "filter_type_0/Slice_3/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_8/shape" + op: "Const" + 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: "filter_type_0/Reshape_8" + op: "Reshape" + input: "filter_type_0/Slice_3" + input: "filter_type_0/Reshape_8/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/matrix_1_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "%\260\356\233dp\327?\0347\242V\356\214\304\277\005\242\363\316\313\374\330?\261\213\331<\235c\355?\216[\256\037\014\355\260\277\'\272u\302\260K\314?F@\223$#T\334?\032}o}\'\343\325\277z\322\214\235\336\325\330?bc\333\300\251c\322?" + } + } + } +} +node { + name: "filter_type_0/matrix_1_1/read" + op: "Identity" + input: "filter_type_0/matrix_1_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_1_1" + } + } + } +} +node { + name: "filter_type_0/bias_1_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "1\036j\321\375\307\353\277\220\232\241C\277\302\251\277%`kJ\252\343\270?\210\307\223F\032j\372\277D\214\367(V=>?\230\345L\340\345\204\363?\31375\225\201\245\331\277\231#a\200\003\234\365\277\311\035\033; i\342?\0256\277L\221o\350\277" + } + } + } +} +node { + name: "filter_type_0/bias_1_1/read" + op: "Identity" + input: "filter_type_0/bias_1_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_1_1" + } + } + } +} +node { + name: "filter_type_0/MatMul_4" + op: "MatMul" + input: "filter_type_0/Reshape_8" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_5" + op: "AddV2" + input: "filter_type_0/MatMul_4" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_3" + op: "Tanh" + input: "filter_type_0/add_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_9/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_9" + op: "Reshape" + input: "filter_type_0/Tanh_3" + input: "filter_type_0/Reshape_9/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/matrix_2_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\027Z\350\243\022<\260?\202`\225\036\226q\307\277\217c\323l\213/\245?\361\250\234<\026|\360?\272y[\016\354H\302\277\274R\356\327\205\200\336\277X\320\1778\037\372\257?\367I\265\354~{\351\2777\271d\320\214\334\352?\212\035\374\342\367\"\327?t\320\243q\247\302\202?\334\227\377K\230\265\313\277\354-*\")B\321\277M\224]S\000\325\261?\274!\t:w\031\306\277\311\177\376\376\260\315\317\277\222\214O\0021\315\217?z\323g\334\023\331\270\277\260V\305\220\205\r\327?\270\325\3535\356\344\320?Q\371.7\340\354\271\277\201J[\017\'\213\320?\336\202\202\371\035\245\307?\246\256Ik\240\343\322?X\357\017\237eM\235\277Hi\024`6\013\246\277\272\ngS\373\251\324??9\374b\250|\340\277\345`\242\217S^\317?\024\255\372\"Fj\241?yo\326\037\222\215\351\277\321\3765\260\252p\340\277UGKf\313\315\272?\022\013\3631\305\337\301?\303\177\263\234\326\367\266?\253\366\217O],\321\277S\355l\244\312I\301?\247\3367\2010G\341\277\307 \\\005\213\207\366?$\215U[\217\177\341?\346#E{G\301\310\277S\215DKb\322\320?\262*\204\314\237<\242?\366{\252\264K\244\320\277:B\231k\205\255\300?n\022\205\007\254}\272?\"\232G\352g\261\235?\201\204ol\220\303\211?n\2605\275G\233Y?h\002\211\365\370.\326\277N\365k\201:\315~?\036\202\005]\037\333\275\277\016\341l\351j\371\302?\210#\324e\022\323\220?\231\307\023\252Y\330\222?\272\236\212\377\333\214\303?v\022p\034Y\002\324?\226\300\236\002\036S\302?E\320\013\027\225\361\325?\"\264\022\267\3267\265?\206Cl(\332\'\220?J\263\254\316\240v\325?\352k\014+M\001\246\277\177\001}\377\010cu?MI\237\266\220d\324\2779\241v\353\020\347\324?\014\324\306e\371O\272\277\331\231\244\\\"\317\322\277\266\254_A5\306\334?1\357\007\203\361\013\265?\004X\300\302t\341\313\277(\252m\246 \036\331\277\233w\316\231%\270\323?&#h\311\032\216\305\277\203Z\tl!x\240?Q\271\334\272D\206\255?|\017\254\331\276\370\306\277C\210!\004\241Q\270\277\214b;\353\010\003\311?`\222\037?\366q\314?\272\226\327F\300x\313\277\341\220\377\362\221\335\242\277\177j=\355\226\321\326\277Un\324\r\262\266\334?^\234\235q\227\264\330\277t\240O\364E\242\275?A\3174\031H\343\262\277\216\202A$\027\330\342\277\357\253\005_]Z\310\277\371\t\032\316\207\374\217?n\337\331\255[g\332\277\036\342\016QpX\312\277\255\264\204,\204\275\304?:\226\353~X\302\260?\256\262O/Vm\250\277*\352\243\330\333\307\321\277N\202\3610\273\246\320\277\351(\305\016#\367\244\277$M\r\345\036w\332?>\212n\355\256\310\324?" + } + } + } +} +node { + name: "filter_type_0/matrix_2_1/read" + op: "Identity" + input: "filter_type_0/matrix_2_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_2_1" + } + } + } +} +node { + name: "filter_type_0/bias_2_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\304\3075\374\\\315\350\277j\350h\335T\275\350?\t\341\371\021\353\374\211\277\023\300\223\2424$\315?\024}\246\003A\t\360?\370\032\204x\230\263\375\277`\276\315],\367\340\277H\005\236\200H\243\342?B(\362\037\262\035\341?]\342\306\3416\223\321?" + } + } + } +} +node { + name: "filter_type_0/bias_2_1/read" + op: "Identity" + input: "filter_type_0/bias_2_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_2_1" + } + } + } +} +node { + name: "filter_type_0/MatMul_5" + op: "MatMul" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_6" + op: "AddV2" + input: "filter_type_0/MatMul_5" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_4" + op: "Tanh" + input: "filter_type_0/add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_10/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_10" + op: "Reshape" + input: "filter_type_0/Tanh_4" + input: "filter_type_0/Reshape_10/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/add_7" + op: "AddV2" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/matrix_3_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\373\373\025 \243\263?\311\031\231\213b\225\340\277|\345=\022)\025\262?<\240\222j\326\310\306\277\2519j\204o\235\263\277\372\367\0277\355\203\333\277N\'\331\022V\274\253?\3675!\022b\301\300\277R\361U\267Z\316\262?/:\035y\270\333\301?\316\237x\322[\330\310\277\332\"\356_H5\244?U\261\376\256T\273\307\277\224{G\354\366\370\320\277\307v\332\t\354S\337?\307}l4\337b\352\277x\352a\345\031\200\275?\3435k\321\356R\246\277S81r\204\337\323\277%r$\003\234\312\331?\274\355-\275\352\260\273?\353\205\2218\342L\274\277\031\371\214u\230&\256\277~\253\246\323\013\241\253?O>\246/\342?\223\366\024r)\357\306?\225\036$\027Z\024\323\277\307(\221g\204\220\305?g]]\211\222\234\301?\236z\363`\376\333\277?\215Z \024\3618\263\277\3075\235\211\240\013\303\277\246\023\3771\213\214\304\277\025\026d\316\322T\336?\362\347nR\265#\315\277\263%5\273\'`\245\277\200zM\261\341|B\277Gc\302\223\205q\310?" + } + } + } +} +node { + name: "filter_type_0/matrix_3_1/read" + op: "Identity" + input: "filter_type_0/matrix_3_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_3_1" + } + } + } +} +node { + name: "filter_type_0/bias_3_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\277\256\t\240q\325\372\277\353{Ea\323`\367\277\315\205[\344\372A\260\277\366\3108\004\022\316\344\277\360\277\035b\377c\331\277(z~\263j$\365\277\240,\342\241\275d\351\277\214\322A\2746\272\350?\026\252J\200J7\335?8gxU\272\003\322?" + } + } + } +} +node { + name: "filter_type_0/bias_3_1/read" + op: "Identity" + input: "filter_type_0/bias_3_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_3_1" + } + } + } +} +node { + name: "filter_type_0/MatMul_6" + op: "MatMul" + input: "filter_type_0/add_7" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_8" + op: "AddV2" + input: "filter_type_0/MatMul_6" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_5" + op: "Tanh" + input: "filter_type_0/add_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_11/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_11" + op: "Reshape" + input: "filter_type_0/Tanh_5" + input: "filter_type_0/Reshape_11/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/add_9" + op: "AddV2" + input: "filter_type_0/add_7" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_12/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\n\000\000\000\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_12" + op: "Reshape" + input: "filter_type_0/add_9" + input: "filter_type_0/Reshape_12/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Reshape_13/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\n\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_13" + op: "Reshape" + input: "filter_type_0/Slice_2" + input: "filter_type_0/Reshape_13/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/MatMul_7" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_10" + op: "AddV2" + input: "filter_type_0/MatMul_3" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/mul/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 0.06666666666666667 + } + } + } +} +node { + name: "filter_type_0/mul" + op: "Mul" + input: "filter_type_0/add_10" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Slice_4/begin" + op: "Const" + 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: "filter_type_0/Slice_4/size" + op: "Const" + 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\377\377\377\377\006\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice_4" + op: "Slice" + input: "filter_type_0/mul" + input: "filter_type_0/Slice_4/begin" + input: "filter_type_0/Slice_4/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Slice_5/begin" + op: "Const" + 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: "filter_type_0/Slice_5/size" + op: "Const" + 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\003\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "filter_type_0/Slice_5" + op: "Slice" + input: "filter_type_0/mul" + input: "filter_type_0/Slice_5/begin" + input: "filter_type_0/Slice_5/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/transpose/perm" + op: "Const" + 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\001\000\000\000" + } + } + } +} +node { + name: "filter_type_0/transpose" + op: "Transpose" + input: "filter_type_0/Slice_5" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/MatMul_8" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_0/Reshape_14/shape" + op: "Const" + 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<\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_14" + op: "Reshape" + input: "filter_type_0/MatMul_8" + input: "filter_type_0/Reshape_14/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_8/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_8/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_8/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_8" + op: "StridedSlice" + input: "Shape_1" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_9/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_9/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_9/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_9" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_3/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_3" + op: "Mul" + input: "strided_slice_9" + input: "mul_3/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_7/shape" + op: "Pack" + input: "strided_slice_8" + input: "mul_3" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_7" + op: "Reshape" + input: "filter_type_0/Reshape_14" + input: "Reshape_7/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Shape_2" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_10/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_10/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_10/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_10" + op: "StridedSlice" + input: "Shape_2" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_11/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_11/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_11/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_11" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_4/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 10 + } + } + } +} +node { + name: "mul_4" + op: "Mul" + input: "strided_slice_11" + input: "mul_4/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_5/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_5" + op: "Mul" + input: "mul_4" + input: "mul_5/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_8/shape" + op: "Pack" + input: "strided_slice_10" + input: "mul_5" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_8" + op: "Reshape" + input: "filter_type_0/transpose" + input: "Reshape_8/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_12/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_12/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_12/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_12" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "add_2/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "add_2" + op: "AddV2" + input: "add_2/x" + input: "strided_slice_12" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_6/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_6" + op: "Mul" + input: "add_2" + input: "mul_6/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_13/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_13/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 4 + } + } + } +} +node { + name: "strided_slice_13/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_13" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_7/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_7" + op: "Mul" + input: "strided_slice_13" + input: "mul_7/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Slice_1/begin/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "Slice_1/begin" + op: "Pack" + input: "Slice_1/begin/0" + input: "mul_6" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_1/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice_1/size" + op: "Pack" + input: "Slice_1/size/0" + input: "mul_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_1" + op: "Slice" + input: "Reshape_4" + input: "Slice_1/begin" + input: "Slice_1/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_9/shape" + op: "Const" + 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<\000\000\000" + } + } + } +} +node { + name: "Reshape_9" + op: "Reshape" + input: "Slice_1" + input: "Reshape_9/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/Slice/begin" + op: "Const" + 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: "filter_type_1/Slice/size" + op: "Const" + 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\024\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Slice" + op: "Slice" + input: "Reshape_9" + input: "filter_type_1/Slice/begin" + input: "filter_type_1/Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape/shape" + op: "Const" + 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\004\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape" + op: "Reshape" + input: "filter_type_1/Slice" + input: "filter_type_1/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/Slice_1/begin" + op: "Const" + 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: "filter_type_1/Slice_1/size" + op: "Const" + 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: "filter_type_1/Slice_1" + op: "Slice" + input: "filter_type_1/Reshape" + input: "filter_type_1/Slice_1/begin" + input: "filter_type_1/Slice_1/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_1/shape" + op: "Const" + 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: "filter_type_1/Reshape_1" + op: "Reshape" + input: "filter_type_1/Slice_1" + input: "filter_type_1/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/matrix_1_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\274\376\214C\225~\304\277O\013\200E\236\035\340?\026\326\200\224f\020\235\277\275\307\235\001{\354\304\277\264F\206n\356\000\325\277x\376\307\316\377\233\322\277\263`ee\371\034\256?\310\333\377\001\357=\322?\203\004\370=\247\013\247\277\262nV\366II\326?" + } + } + } +} +node { + name: "filter_type_1/matrix_1_0/read" + op: "Identity" + input: "filter_type_1/matrix_1_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_1_0" + } + } + } +} +node { + name: "filter_type_1/bias_1_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\334\237n\354o-\324\277\303\036H\225K\336\347\277\2642\264K\346\364\357?C&t\r\372G\275?y:@M^\343\317?\306\347\201\'\337\260m\277\364\362\'\221\t\334\373\277E%\244G+\365\252\277\032\177\247_\254/\274\277\353_\n\277\366\264\373\277" + } + } + } +} +node { + name: "filter_type_1/bias_1_0/read" + op: "Identity" + input: "filter_type_1/bias_1_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_1_0" + } + } + } +} +node { + name: "filter_type_1/MatMul" + op: "MatMul" + input: "filter_type_1/Reshape_1" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add" + op: "AddV2" + input: "filter_type_1/MatMul" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh" + op: "Tanh" + input: "filter_type_1/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_2/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_2" + op: "Reshape" + input: "filter_type_1/Tanh" + input: "filter_type_1/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/matrix_2_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\231\030t5\033C\312?\006#\034\t\036M\273?\276\202\020\331\357\016\330?yI+\264/\262\313\277\273\037\0037#p\341?D\273\354\336\227|\276?\376\310Z\014^\000\311?c\'W\341\330\317\276\277,M\225\261\231z\331?\336\203\n\235\177\371\246?$\366\331M\033L\311?\025W\312\344F-\300?4\272\363S+_\324\277\333&\332OW\274\310\277w\230\324\273\375\021\335\277S\034\203g\350\311\265?\257\304\274\037F\026\312\277\312z)\234q\'\336?<\013\321\nU|\327?A\237yR\233~\266\277\020\367,\215\245[\321?\3061,\217m\265\267\277F\211\264\355\217\277\324\277\203u/\376o\253\306\277\314\205\033Ux\261\323?W\225\002n\257\037\241\277\374\356}\362\322W\257\277{\017\022\321\333\235\300?\350\333T\320\235\313\201?\311\347\261F\353>\315\277\014\353\373\327\374\273\310?},*^\267\203\324\277\317.\211\340\350\363\324?i\266*!\003\224\320?>n\226\023\375A\340?n($\003\016\206\235\277^\325\317s\022\271\307?\021>\211gO\254\342\277i\230\242\230M\243\341\277\0354\205\274\016-\332\277\365\016\321\271\265/\233\277\313\236J\020\217\361\301\277\247p\355\222h\364;\277\233\226\374\376\240\345\202\277Y\305\232\374\024\241\244\277n\366r \n\263\235?x\377\254\'\247\216\321\277.o&\240\357\260\324\277\354\200\231\326O\\\310\277m[\010\305\337H\334?\315\262\344\350l\226\276\277)\332\031\003\345\367\301\277\347\207\tT\231?\300\277M\221\345\251\001g\234\277\320\026\243\330Z\210f?\321\212\303\032?V\277?\224M\264\2308`\224\277\364\177\327\320\226\313\231\277\367qE\247\201\317\226\277\312\022\030S\022W\324\277\304\000\013 \216\331\244?Or\306H\362\220\271\2776\345;?\351\240\261\277\014\023\314\257\220\341\271?\"w\033\347\242\036\316?\302\312\343\223U!\246?Z\360\375f\210[\270?\364F\313\225zg\260?\366\352S|\272\016\310?\231\037\t\200#w\251\277e\032\017\277.\316\271\3444\317\303\277\347\214J>\221`\276?\251\372\303\255\217g\301?\325\010hf\\\007\277?\024\315\363\037\207\247\317\277\333YQ\206\263\273\213\277,\374\270zq\323\233?\032\026#\201\300\001r\277\257\224\326\273\233\024\247?\273\306\200\334\225\374\325\277\027\341\255\327\326Y\312?\306\006\277qd\347\311\277\230\032\253\357\235\225\264\277\267RF\201\004\347\340\277$T\240\265\322f\320\277\325?6\333\330\"\232\277:\256\377\'5D\331?\204\337\260M\354\224f?\017Tj\2010\243\326?\033\006>\371\230\025\331?``\226uq$\323?" + } + } + } +} +node { + name: "filter_type_1/matrix_2_0/read" + op: "Identity" + input: "filter_type_1/matrix_2_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_2_0" + } + } + } +} +node { + name: "filter_type_1/bias_2_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\272\304#\021\034\314\344\277\352g\306\021\375\032\320?\332\035\210\302\024\325\325\277U\036\315\005g\211\333\277\320\013\305\240\334\035\345?8a\305\375\216\364\345\277\236\340\267%y\304\363\277\377*\301X\276b\306\277\210\004\234\276+p\252?\343X\316\316j\371\341\277" + } + } + } +} +node { + name: "filter_type_1/bias_2_0/read" + op: "Identity" + input: "filter_type_1/bias_2_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_2_0" + } + } + } +} +node { + name: "filter_type_1/MatMul_1" + op: "MatMul" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_1" + op: "AddV2" + input: "filter_type_1/MatMul_1" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh_1" + op: "Tanh" + input: "filter_type_1/add_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_3/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_3" + op: "Reshape" + input: "filter_type_1/Tanh_1" + input: "filter_type_1/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/add_2" + op: "AddV2" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/matrix_3_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "I\016\033U\"6\245?3\264 K\211\277\230\277\271\373{\243}w\326\277\315\022\227E\343\265\220\277[^\365\215\335\022\275\277\273\022Z\215\360\250\305\277q\221\225\251\242_\337?\213\201\034\237\301\025\277?\313\370\325\n|\312\305\277_\240\272\317\004C\312?\266\204\300\342\017\023\234\277\021\\\345[x\000\253\277\252k\207\273yW\322\277@\350\030\356\013@\340\277\267\233\262\270|\265\342?[\210\034\2102U\271\277\265\035Jl\330@\324\277.\353\320\246\302\245\332?&\361\177]\351K\322\277\004\2618\262K\364y?+;\020fg\274\323?&\026c\224\352:\312\277zu%\002\211\331\350?\350Dr\371o\024\327?\302\200\253Tu\250\306?\254\020\202M\313\257@?x\t\365\302\232\242\343?Q9\033\276^\027\322?\345=r\262\344\352\260?\377\272X\rJ\274\276\277\204y\302\016\206\210\320\277\016)\3215\260\026\335?\221\t,ZXL\310?\326\237\221=\370\225\252?\307\324\273\005p7\302?\215?f1k\263\335\277\261\027s\013t\357\310?\323\343\223OO+\271\277+p\216q>N\312?e{\307\330t\036\315\277\376\252\260\313\373&\270?\021\246\007)\177\242\336?\250\307FI\027\231\322?\336\257\3126\007\t\343?\370J\343\030\3530\300?R\3240\205\026\277\337?\22041\242\'\030\324\277\207\276\013S\332\322\264?\345\366%v\337V\305\277\200hM\305.\352\340? R\004z\221\013\265\277P3\337!M9\260?\337\304\311\225\004\312\252?\014)%\377\376-\275\277\261\362W\204G\352\327\277\006\254\215\016\331\024\311?\347\30094\243\220\263\2770\330\321\220\026\246\267\2779=\220\n\261\262\325?\243\337\345\323q\361\302?\213\217\177\203zx\246\277\355?$\020\310b\274?\231\316\363>\240/\277?\352\357\262\221aO\331\277\274\244\371>V-\307\277\201c\257Y\226^\252?\367-\250\356\367\346\335\277\310\374\021\243\250\353\303?]\\1\273\205\250\254\277\221\244~\376V\360\326\277\277\342\033i\363\221\336\277\321\326{\273x\305\224?\317\333b\301\274\035\351\277\010\006\234\366\332\215\314\277\273\353\222\360\363+\311\277\206\306\267+\347\203\330\277s\275\005*i\\\342\277\323\330\377~\001\302\323?\274)\362iff\300\277_\246x\335\264\300\276\277\377\3535\345[J\303\277\000\265\370\006\031|\320\277\234)Q8\351\035\327\277\301\251\247\360\233@\325\277\262\036H\247\025e\316\2777\n\353\370\361\364\312\277Qk\363B\360\023\204\277\320\334\212n\242\354\256\277P\3537L\302\202\333\277\r@W\314\006:\263?\';F\004\354\346w\277Lq\265\337\377\001\321\277`\272:(\202\014\325\277\3226\255\027D\355\252\277j[\224\241\320\265\303?\316H.O\260,\313\277 \024\256\330\204\357\257?\243\034\031\337\321\334\303?5\037\032\212<\364\323\277O\020\230\2659\270\242\277" + } + } + } +} +node { + name: "filter_type_1/matrix_3_0/read" + op: "Identity" + input: "filter_type_1/matrix_3_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_3_0" + } + } + } +} +node { + name: "filter_type_1/bias_3_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "9\327|\257s\020\326\277+[\234\256\325\333\357?3\366\241\214d\003\202?G\203\366\213E\313\342\277\216\231\337\344\034,\324\277\032\252\332\3753%\263\277A\246h\001f\330\224?\'M\317h\214|\261\277/\240\304\361\377\362\243\277\244;k:\340\304\001@" + } + } + } +} +node { + name: "filter_type_1/bias_3_0/read" + op: "Identity" + input: "filter_type_1/bias_3_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_3_0" + } + } + } +} +node { + name: "filter_type_1/MatMul_2" + op: "MatMul" + input: "filter_type_1/add_2" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_3" + op: "AddV2" + input: "filter_type_1/MatMul_2" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh_2" + op: "Tanh" + input: "filter_type_1/add_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_4/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_4" + op: "Reshape" + input: "filter_type_1/Tanh_2" + input: "filter_type_1/Reshape_4/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/add_4" + op: "AddV2" + input: "filter_type_1/add_2" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_5/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\005\000\000\000\n\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_5" + op: "Reshape" + input: "filter_type_1/add_4" + input: "filter_type_1/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/Reshape_6/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\005\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_6" + op: "Reshape" + input: "filter_type_1/Slice" + input: "filter_type_1/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/MatMul_3" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_1/Slice_2/begin" + op: "Const" + 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\024\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Slice_2/size" + op: "Const" + 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(\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Slice_2" + op: "Slice" + input: "Reshape_9" + input: "filter_type_1/Slice_2/begin" + input: "filter_type_1/Slice_2/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_7/shape" + op: "Const" + 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\004\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_7" + op: "Reshape" + input: "filter_type_1/Slice_2" + input: "filter_type_1/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/Slice_3/begin" + op: "Const" + 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: "filter_type_1/Slice_3/size" + op: "Const" + 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: "filter_type_1/Slice_3" + op: "Slice" + input: "filter_type_1/Reshape_7" + input: "filter_type_1/Slice_3/begin" + input: "filter_type_1/Slice_3/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_8/shape" + op: "Const" + 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: "filter_type_1/Reshape_8" + op: "Reshape" + input: "filter_type_1/Slice_3" + input: "filter_type_1/Reshape_8/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/matrix_1_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\213\363\262\335V\025\327\277\203\314]\035B|\273\277\311\0105\223\231\221\335\277\311\217\014\345\274\216\307\277\227\265yu\351+\335\277\\\034^x\252O\303?^,\223\305\363\323\314\277P\027\351\263\333!\332?\327\335\335\233)\233\311?\300\030\006h\203\246\306?" + } + } + } +} +node { + name: "filter_type_1/matrix_1_1/read" + op: "Identity" + input: "filter_type_1/matrix_1_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_1_1" + } + } + } +} +node { + name: "filter_type_1/bias_1_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "aN-J=\236\375?\245\325\242\2669K\362?\204;\374\336[\201\346?7\352\303\004\003&\370\277M\237\332M\235\203\365\277\n\017\361npq\356?\254\322\376\235\263\332\335?T\035\204\202\272\305\346\277\026\335\350\306\374R\304?\241\313~\316+\213\263?" + } + } + } +} +node { + name: "filter_type_1/bias_1_1/read" + op: "Identity" + input: "filter_type_1/bias_1_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_1_1" + } + } + } +} +node { + name: "filter_type_1/MatMul_4" + op: "MatMul" + input: "filter_type_1/Reshape_8" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_5" + op: "AddV2" + input: "filter_type_1/MatMul_4" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh_3" + op: "Tanh" + input: "filter_type_1/add_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_9/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_9" + op: "Reshape" + input: "filter_type_1/Tanh_3" + input: "filter_type_1/Reshape_9/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/matrix_2_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\333\265^8\033\020\317\277%r\354s=m\342\277f\247\037\000:\177{?\252\341\317\013[\017\307?\330\370\277)/\r\307\277\365\344\235\247N\225\216\277`\013\340_\246s\322\277\277\377\230{\\\034\323?\263*\034\356\257\034\311?\363\314\213\315%\030\243\277!\370P\204g\205\303\277\352\033p.\343\344\335\277r\321-\276\346$\331?n\351\253\035\304V\307?\336\231\214\2667q\320?\023\353|\257\355 \336\277\373\244\3352\221j\246\277r\203Mp\006I\335\277]t\366\314\rx\305?\252\351/\242\225\316\313\277\305Y$\377W\021\264\277\\=\374\332\020\t\335?J\263\250\210Y]\330\277OV\244r-\203\315\277w\246DC;\200\302\277\243\r2\347\251\313\261?\264p\272\014\253q\320\277\210\363M\305n\363\307?\227\356R\252\350\006\272\277K\234\343\032#X\326?\273\221\002L&\226\266\277\362l\250i\326\024\303?W9\353\010\257R\301\277\000\025\265_T\304\322\277?+F\007B\303\323\277\372;\005lM\013\317?_S\365\007\001\350\261?y7>?}\300\267\277-\261;y]U\325?\367MyN\3644\316?\217\301\302mH!\306?\203\371\231E\0327\326?\246\016\325\374?\310\311\277\247\332iA\364x\244?\265\370\346i\3008\227\277\365s\312j\235\232\301?\320HB_|u\316?\363W\276\302y\177\273\277\002\250\367\304\255j\246\277t3\255\037\353\345\300\277\321\247Y\3746O\275\277@\036\375\023\246\255\253\277g\361{!\241N\320?\365\321D\246\350\215\330?\3713nD\207\223\266?\003\337\264\004\206I\267\277\257<\"\341\177\244\322?\270\023\230Z\305y\331\277\'\033\370\0149%\270?\026g\200i\2536\337\277\020\364\017\032\r\215\250?$T9\371M7\272?\225\206\362\031\256I\237\277\336\303*\301%\256\300?\304\177g\366#\306\300?-\364e\302Y#\300?\375<70\037\200\206\277a\345\300\021i\032\227?,\343k\263,\360\336?\251\324\014\224\376\357\236\277\245+\302\272\001\201\221\277\224Yq\272o\356\306?\r\210\374\002\271\340\322??0K\261\000\020\267\277\013\304|\370\034G\304\277\274\331\276\253\204\013\242\277\314\314\240\335\237\n\323?\261V?{\361\r\321\277\241X:\261b\036\333\277\364\016D,\033\026\323\277\27623\222\007\232\325?\'\001\324\242\273\016\326\2778\334\375\323\245\374\266\277f\343bO\021\351\312\277\214\376\272@\320J\325?L/\337\305\277,\307?W\306Z\272n\'\325\277\343<:\242\310\345\322\277\2456<\342!\013\320?b`\271\221\254\327\304?\221\327\n\260\310\017\315\277\300\030\342\303\222+\243?\236 K\344T\205\247?+\3114\346\327\034\301?\033AHz\253\350\326?\262c\340\273\241\313\326\277\244\233mBY\177\321\277\362\334\322 V\370\306?\314\323o\177i{\271?t\320\353\033\243?\277\277" + } + } + } +} +node { + name: "filter_type_1/matrix_2_1/read" + op: "Identity" + input: "filter_type_1/matrix_2_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_2_1" + } + } + } +} +node { + name: "filter_type_1/bias_2_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: ":\265\234\222\003\023\321?\342A\006\333\365Y\347?\030~\017\267\0160\266?\334f\315h\034\035\311?n\035\357\337\201\006\365?V\327\320\310)\333\303\277w\346L\355T\366\324\277\023s5C\242\030\354?\255TTP\004\315\361\277\212(v\370\037`\361\277" + } + } + } +} +node { + name: "filter_type_1/bias_2_1/read" + op: "Identity" + input: "filter_type_1/bias_2_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_2_1" + } + } + } +} +node { + name: "filter_type_1/MatMul_5" + op: "MatMul" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_6" + op: "AddV2" + input: "filter_type_1/MatMul_5" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh_4" + op: "Tanh" + input: "filter_type_1/add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_10/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_10" + op: "Reshape" + input: "filter_type_1/Tanh_4" + input: "filter_type_1/Reshape_10/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/add_7" + op: "AddV2" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/matrix_3_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "j\210\276\260\216\216\310\277\224<\324:k\247\311?\200|\200\371g\241\305\277pl\335\355\371[\222?\224\\\204\347\262\202\313?\232\202t\262\230\247\312\2772\346m\"\023\357\340\277\211\010\224\036\272\234\276\277\270\007\344q\260\023\273\277\275\244I\023\342\010\272?wjn:\241\374\307\277\336%\363\203\203\275\322\277\334\355lWe\026\311\277\212t\222\0139\325\227\277\360a\013\362\343,\301?@bL\231_\202\315\277\346Q\2215\361a\243\2770\240V\204\362\\\325?\272\010&\255-;\320\277!=\371\000 r\326?\315p\356X\225\207\206\277@\362c\2478)\302\277\233SF\022\271w\264\277\270\261\r5f\315\321\277n;\033\335\203\031\272?\037i&+\365\202\323\277y\034\211_(D\302\277\223\241\240w}G\312\277\305\326u\330[\302\325?J\301\257J\003(\325\277I\372\204\362\315?}\t%*\253\374\220?@?\027\225\3530\321\277\336\024k\274\321\027\272?\\\030\036\010\216\033\214\277\356\220t\007C;\323?-\017\370\357z\323\311?p\346.4\375B\275\277T \242\3048\002\304?j\303\263gr{\263?n\204X?\030\223\300\277/h\302\032N\306x?\224\335H)\224r\314?\262V\276\215Yg\223?\272\3307\242z\252\310\277\364B\\\t\272\027d?^\220\330\2422H\304\277(\233\266\250s\r\247?U\230\266\006\256\032\312?\247/\016=\254\t\316?\207\355u\236-\207\316\277\223R\020\255g6\311?d\272\204A\262`\322?\321U\252@DD\212\277\342\346\375\360v\263\245?\260.\351\2617\354\341\277\266\203\t\215\246k\251\277\202]\210\003\025\226\265\277\014\370C\210\\\253\333\277\323\356G\211l\025\326\277\303\344\355\341\325\260\324?w\254\215\306\333/\332?\357\373\023%B\306\302\277\277\037\320k\337\004\332?3\\\323\212\2419\301\277\034]W\031V\265\257?\217VV\3253:\250?\306kK\254\247\325\256\277\177\335+\321^\257\313?j\331\214\362\r\266\271\277\036\030\3701(\352\303?\202\275\334\316\373\342\334\277{\340W\271,\330\320?\022\313CK\246\376\336?\261Bn~\000*\325\277O\363\226\315\246~\304\2774\000)|r\364\303\277\217\271\375\034\236@\305\277N\327\214\004\001\370\262?\250\213\364W\313Dt\277%\373%\324\020F\235?^\267.\235\025\301\267\277D\305\"\n\036_\326?]@\222Ex\307\312?\366wp:au\304?\320i\022\367\215\347\327?\010\354D\365\231\214\323?O\267\370\351\325J\320\277iWsP\010\220\247?VC\341\367\350\013\326\277q\245\315\307\333\344\220?xFc~F)\312\277:\004\247\263X\272\314\277\353\260C\356\216\377\271\277" + } + } + } +} +node { + name: "filter_type_1/matrix_3_1/read" + op: "Identity" + input: "filter_type_1/matrix_3_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_3_1" + } + } + } +} +node { + name: "filter_type_1/bias_3_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\317,;\216\257\222\355\277j5\321\005L\306\310?\240\326\t\374\t\342\351\277\237b}\203\222\320\345?\371\216\335-G\276\342\277\340S\314K\202\034\263\277\000Y\201\305v:\312?Z\306M\333\244\r\360?\267\266\374\213%\000\344?\026\270\'/+\265\320?" + } + } + } +} +node { + name: "filter_type_1/bias_3_1/read" + op: "Identity" + input: "filter_type_1/bias_3_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_3_1" + } + } + } +} +node { + name: "filter_type_1/MatMul_6" + op: "MatMul" + input: "filter_type_1/add_7" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_8" + op: "AddV2" + input: "filter_type_1/MatMul_6" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh_5" + op: "Tanh" + input: "filter_type_1/add_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_11/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_11" + op: "Reshape" + input: "filter_type_1/Tanh_5" + input: "filter_type_1/Reshape_11/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/add_9" + op: "AddV2" + input: "filter_type_1/add_7" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_12/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\n\000\000\000\n\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_12" + op: "Reshape" + input: "filter_type_1/add_9" + input: "filter_type_1/Reshape_12/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/Reshape_13/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\n\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_13" + op: "Reshape" + input: "filter_type_1/Slice_2" + input: "filter_type_1/Reshape_13/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/MatMul_7" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_10" + op: "AddV2" + input: "filter_type_1/MatMul_3" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/mul/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 0.06666666666666667 + } + } + } +} +node { + name: "filter_type_1/mul" + op: "Mul" + input: "filter_type_1/add_10" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Slice_4/begin" + op: "Const" + 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: "filter_type_1/Slice_4/size" + op: "Const" + 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\377\377\377\377\006\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Slice_4" + op: "Slice" + input: "filter_type_1/mul" + input: "filter_type_1/Slice_4/begin" + input: "filter_type_1/Slice_4/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Slice_5/begin" + op: "Const" + 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: "filter_type_1/Slice_5/size" + op: "Const" + 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\003\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "filter_type_1/Slice_5" + op: "Slice" + input: "filter_type_1/mul" + input: "filter_type_1/Slice_5/begin" + input: "filter_type_1/Slice_5/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/transpose/perm" + op: "Const" + 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\001\000\000\000" + } + } + } +} +node { + name: "filter_type_1/transpose" + op: "Transpose" + input: "filter_type_1/Slice_5" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/MatMul_8" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_1/Reshape_14/shape" + op: "Const" + 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<\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_14" + op: "Reshape" + input: "filter_type_1/MatMul_8" + input: "filter_type_1/Reshape_14/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Shape_4" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_16/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_16/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_16/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_16" + op: "StridedSlice" + input: "Shape_4" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_17/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_17/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 4 + } + } + } +} +node { + name: "strided_slice_17/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_17" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_8/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_8" + op: "Mul" + input: "strided_slice_17" + input: "mul_8/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_11/shape" + op: "Pack" + input: "strided_slice_16" + input: "mul_8" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_11" + op: "Reshape" + input: "filter_type_1/Reshape_14" + input: "Reshape_11/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Shape_5" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_18/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_18/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_18/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_18" + op: "StridedSlice" + input: "Shape_5" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_19/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_19/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 4 + } + } + } +} +node { + name: "strided_slice_19/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_19" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_9/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 10 + } + } + } +} +node { + name: "mul_9" + op: "Mul" + input: "strided_slice_19" + input: "mul_9/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_10/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_10" + op: "Mul" + input: "mul_9" + input: "mul_10/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_12/shape" + op: "Pack" + input: "strided_slice_18" + input: "mul_10" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_12" + op: "Reshape" + input: "filter_type_1/transpose" + input: "Reshape_12/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "concat" + op: "ConcatV2" + input: "Reshape_7" + input: "Reshape_11" + input: "concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "concat_1/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "concat_1" + op: "ConcatV2" + input: "Reshape_8" + input: "Reshape_12" + input: "concat_1/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "o_descriptor" + op: "Identity" + input: "concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "o_rot_mat" + op: "Identity" + input: "concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "strided_slice_21/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_21/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_21/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_21" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_11/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_11" + op: "Mul" + input: "mul_11/x" + input: "strided_slice_21" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_13/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_13/shape" + op: "Pack" + input: "Reshape_13/shape/0" + input: "mul_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_13" + op: "Reshape" + input: "o_descriptor" + input: "Reshape_13/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_22/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_22/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_22/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_22" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_12/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 30 + } + } + } +} +node { + name: "mul_12" + op: "Mul" + input: "mul_12/x" + input: "strided_slice_22" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_14/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_14/shape" + op: "Pack" + input: "Reshape_14/shape/0" + input: "mul_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_14" + op: "Reshape" + input: "o_rot_mat" + input: "Reshape_14/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_23/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_23/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_23/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_23" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_13/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_13" + op: "Mul" + input: "strided_slice_23" + input: "mul_13/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Slice_2/begin" + op: "Const" + 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: "Slice_2/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice_2/size" + op: "Pack" + input: "Slice_2/size/0" + input: "mul_13" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_2" + op: "Slice" + input: "Reshape_13" + input: "Slice_2/begin" + input: "Slice_2/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_15/shape" + op: "Const" + 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<\000\000\000" + } + } + } +} +node { + name: "Reshape_15" + op: "Reshape" + input: "Slice_2" + input: "Reshape_15/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_24/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_24/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_24/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_24" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_14/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 30 + } + } + } +} +node { + name: "mul_14" + op: "Mul" + input: "strided_slice_24" + input: "mul_14/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Slice_3/begin" + op: "Const" + 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: "Slice_3/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice_3/size" + op: "Pack" + input: "Slice_3/size/0" + input: "mul_14" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_3" + op: "Slice" + input: "Reshape_14" + input: "Slice_3/begin" + input: "Slice_3/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_16/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\n\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "Reshape_16" + op: "Reshape" + input: "Slice_3" + input: "Reshape_16/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_25/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_25/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_25/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_25" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "add_4/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "add_4" + op: "AddV2" + input: "add_4/x" + input: "strided_slice_25" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_0_type_0/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 60 + } + dim { + size: 10 + } + } + tensor_content: "\205\211n\322\350\343\264\277\000\024y\037\343\202y?\250\215\325\226\244\024\307\277\225?;\034\200\203\240?\223\360&\334\201\317\323?d\335\316\2645\202\275\277F\271uLQ\225\244\277L\313\347Q\"\356\314\277\006Hq9\023|\302?\345\270V\237r\023\320\277na{\277\001\232\247\277(\264\n\231i\016\273\277)\360\303\265\034~\262\277&\354\016p\006\014\320?9e\307\265P\245\304?8Y\021\2477,\272\277h\201\272\342\306 \306\277\254\225<\031\204\026\320?\267\002\271!i\261\266?\331A\316\025t\325\266?\033\214\022?W\037\265\277Y\274n*\351\377\271?\001F]>b-\256\277L\237\0268d\022\317?\024z/\310\353Z\302?\366\245\034\366\016\337\267\277\363\010\263\277\376%\302\277\217\240S\233\010\244\324\277h\213\266\036L\207\301\277\200\036\016\013\341\365\306\277\355\222I\"\025B\311\277\177h\267\342\253@\233\277\346\231\246\236\236\032\263\277i\366\362+\335\260\256?o=:\006)\262\245?\275!\316\301*\261\267\277\313\271\014\327\200\022\253?\377\007u\305\254\360l\277d\216\001tj:T?\220\226d\275r\367\321\277(\256\311\263\025}}\277\233\345\211A\227i\304?h0\317\204\375\037\263\277W\2620\332y\202\304\277\263\202\312-\031yn\277\227Q\254\226+\375V\277e\336\030R\2457\271\277\371\014\t\014\201\262\261?\244=\205E\274Q\250\27730\215\274i\227\305?h\022\243\035\302\335\301\2775*/c\343W\215\277\374p[\277\242Z\300?\373\276\206\241\273\036\275?(\346(\373\372N\310\277\213\245\343\006\235\205\210\277\271fO\260\323\237\260\277\336\267\\\237_+\267\277N1\277\256\347\034\264?\377\260\231\337\362\261\250\277\352n5\362\330\023\260?\037\341Dq\302\177\231?!\215\326\367Oq\316\277v\037\3758\353<\272?\354B\265P\226\211Q\277ri\352zm\005\247\277DR\322;\313\364\274\277\355\311$f\326\002\301?\234\177B\225\213\266\303?\204\334\017\312{t\321?\026\005e\355\362\271\265\277\217\260\216m\222\265\301?\n\236\312\300\250L\276\277\341\377VK\250\001\263\277\273\271$\265\\\037\305?\244\341\001\003\204\311\255\2779\211\025\204\\N\320\277\370\257\243\261\366.\315\277\270\234\230pc\345\310?\310\354\246#[\350\272\277\034\251\260\345\300R\300?\304\001\3047\336,\267?\315\232\311\202>)\254\277\025^\222\002\376H\302\2779]aX\337U\302\277Dj\306\321\245\244\315?On\377\230xw\241?,r\006\010J=\235\277P\006$/\230\323\226?2G\243\254\033\257\211?\257<\223\377\267\021\312\2778\302\372G\215N\270?\'!0\334\244\016\307\277\017}wF\265\273\256\277W\330\033\317\'\216\206?\007*\235\344bu\321\277 [W\254\022\373\302\277\316^\304\2131<\246\277a\273\222\254\272F\312?\204\244\034\036:\333\334\277\210\317\276W2\331\236?\323\214U\373z\360\313\277\276\025\\\002\277\204\305?\373\004EKF\025\234\277C\375\257[pV\265\277\346-\034\271n\032j?X\217\250\002\350\267\311?\207\365j\300m\211\266\277\262a\250\353\247\223\306\277\227\001\t\342\337d\323?\317\271%o`\304\227?\226\3718\271\321\\\314?\322\002\017\"~\220\251\277Fhoa\205!\274?+\206\346\252\374\206\254\277\327N\351\030\301\013\330\277)\026(\335\376e\305\277\222;\221B\205>\310\277|\200\200A\363\304\262\2777\225\315r3r\333\277\310e2*w\010\267\277\341\'\345\370db\236\277`\032\241\350\233+o\277#z;=b\266\320?\333\345\364\345\351\024\325?CUf\374\025A\254\277\236\201\361\307\207+\306\277U0D\204\245\303\226?\276\036[\026\243\321\245\27749\342\366C\037\304\2772\242\253\266\200\240\222\277\234\360N\020Mu\245?#\241|#^\010\262?\322\314%\233\244\004\270\277\005q.lG\325\271\277\210\274\241\201*\232\203\277\001\000\017\370U\177\320\277w\217\375@w\336\276\277D\003\303\302\254\213\330\277~I\2605\030\335\310\277\274k_4\205}\300?$\343\020\036\377\376\302?\213Z\264z\260\330\313\277\311\325\277\227\014l\270?\037\231\256O\360\241\225\277%\212S/\364!\222\277\375\333Z\0063`\274?\005\251=>O\014\244\277Hm\373\316\005$\271?\263\003\227X~\301\275\277D\301\263\376f\221\256?\275sX@\3430\261?\365\336D\301\205s\275?\231\'V\250/f\273\277\212\302\257\364\211\232\323\277U\3029\213b\235\270\277\030[\336\034\265\316\262\277\322\212P\361\333\304\300\277\344\210\272\3076\227\243?\016*\223\031W\246\315\277\326\236=\0356\223\301?U\026\334\317\342<\300??\334\"M\341\353k?\312\207NQ\303\366\255\277\374\275\276\030\202\033\320?\"}\214B \374_?\267\365\0069\341;\315\277\004\221\255\252j\341\270\277\251\027\033\276\027\014\306?K\237D\265]\373\316?T]M\363tm\300?jc\213ri\200\203?\034\232\257;\342B\321?[\363\251\315ya\305\277\264`!\317\000\337\273\277\341\257z\375\t]\316\277\033\303\325\213\232\333\245?dl\331\035;$\240?\274V\360=\260\304\227\277\344\340,\314\211!\323\2775\241\013<\337{\310\277\354\256\315\204\210x\302?\302\300\236\374\253\271\275?}\311\205\032\371\241\315?u\215Z\366\r\272\301?\330\364\331\314\300g\253\277\371\354\330;m\320\320\277M\322>\304\017z\273?\255{Y)<=\302\277M\026q)Fl\252\2772\310\365[uI\305\277\312\\\316tZR\277?\270\226\245\256\236\352\223?\262H{\241=\274\273\277n#\326=\370\223\306\277\355v\270`\246\271\304\277\tRv\030\024\234\305\277z;\367IcX\323\277\323\254\031\311}K\225?\206\226\234u\217\242\306\277R\372\221D\316\377\212?\3279h\316S1\301?\354mh\316Y1\310\277H}\246.\350_\303\277i\267\227\341\002\020\322\277\264\037\352\017h\264\310\277\332\322\230\335\036T\242\277\243\271\222R/k\303\277\367\361\204\301\340e\221\277\355u\317\312F\347\330\277\340\204\330\207N\346\315\277~\372Z\241\272`\306?6\356HJb\022\326\277b\224\341\300,\\\257\277\006\n/Z\240\305\217?\204x\217\230\336\277\322\277\306\323\355\304\'\341\273\2776N7@m\345\301\277\275If\344\214\321\255?\207\243\0224\252n\340\277\375\261\240)\202d\321?|j\230e\020=\242?8\211\337\256\274\370\200\277\257\256\006\205\007\375\256?\005\234\250\r8\251t?\003\333\030\304\303;\322?\223\332P0\177\364\252?e\241+d6c\320?rt3\377\024@\261\277\024W\301\334\rj\301?\201\316\376\n\030x\310\277qu^\363M\327\327? H*\020:\363\272\277\247T\337\334\026}\252\277\224c\246\317\276c\266\277\217\246\032\377\230?\305\277/\323\225\'\326\377\320\277\026\260A\314\021\006\320\277\350\233<\301\210\023\243\277\277Z!\307\347\321\335\277\322\252\227\215q\275\301?\223N\035C\010#\302\277\2313m\027\231\226\200?\256Kk\350\321\270\332\277\034\361\301\263\002o\205\277\213\276\"N(\331\311?p\355\206.A\310\303?\364\007_d\331w\306?t\2640e\224i\304\277\224\035\363\342\215%\276\277\020\236\\\374\331{\314?\001T\361T\211]\315\277\r\n\360g\356\022\323?\032\236\317\227\377\023\307\277 6F\234\271\013\303\277\302\206\353\223b7\307?D\235\036\3103\253\262?\354\213i\0024a\276?H\013w\266~4\300\2775]\244L#o\301?U\233O\230\324\314\262\277\2439\030\202\207\223\272?\330^$\375+\t\200?\356\223x\226\3729\220\277\333\306mMQ\006\271\277\325\370\374\2628:\215?\355\\\240!\332$\262\277LS\2009\232\200\260?mb\264\235::\252?cn~H\177\270\256?K!\312\252F#\266?\306\263.\t\216@\250\277\250\361\273\205|#\320?\214\205d\004\372?\274\277\021\305\320!H\342\300\277\204.\372\2761\323\245\277\337\005z\306\325\224\263?\025\277R\232\016\264\311?\317\330`\257\255\347\263\277\202U9\300\006\303\317?JX3\277\344\362\262\277\335\313\235\ts\001\264?\314@\213\256\3674\275\277Xx\227v.\200\267?:\227\232\356+\026\304?\365f\210\2465M\303\277\270S\330\346b\312\314\277\236\357^zT:\267\2777\276\222uj\'\244\277\203\362\375\024\225\034\305\277w\203h\022\\\013\246?\246\321L\036X\251\272\277-\270\001\177\235\236\323??\350\026.\017L\276?\005\037Z\222e\371\313\277c\\H\265\330|\241\277\022\234\212\200\210\262\304?\344Yg\230f\242\327?\304I\321\351+\340\270\277\320\031e/+\244\316?\036\n\253\314\275\245\302\277\364\314\036\325\226vb?\200\037\217tT\233\243\277\256\312I\354\350z\253?\005\025\272\345c=\310?\361\371\315\263b \272\277\243X\206mWe\230?\022__\333\300\004\261\277\357\241\317cC\353\303?\313\332\000 \361\301\313\277\336\rq\375\n\033\307?\025zB\241\0003\332?\256W1\000\2300\313\277\006\322\030\003\020z\262?,\3720?\356\241j\327\277\277\266\262\265]>\257?\013\343\210\355\343\230\313\277\246\016\032\234\246\300\310?\243U\204\364\014\352\264\277g\314\235\036\332\354\304\277\036wg\031)\217\300?\212\261[\264[\\\302?\002\222%\300:\031\311?)M\363~y\343\335\277!\035- \373\006\325?\346f\275\274\010\344\305\277h\023,\355^q\244?\233\337\232\243\314\026\314\277\340\372\323D\3568\226?4\017\363\036\010\324sS\256\221\300?:\024\374f\321\265\253\277\264\351\215A\324\323\260\277\376\025J\317\251\345\276\277\030*\022\2145\255\275\2773S\177\305%\247\250\277\003F\3359s\033\272?\207\203\241r?\310\301\277\276\264q\270\332\337\324\2778M\307\241\013\345\327\277\361o\256\362\225\306\253\277/\210\035o\300 \260?\326\271\211wl\355\265\277\034\314\345\2525\332\320\277W\303\251\273\364\330\320?P\241\346r\207J\300\277>\035\031$PD\276?g\204u1\356\350\243\277)h\333\030\364\344\300?SU6\204\360B\266\277\200\006:\250\"O\223?\360\335\274UwH\246?\365\323\233\237\002\177\301\277\316\303\215Z\231\236\327\277\020)\276\034c:\214?\343\251\005\201\362\004\264\277O`\032\002\033h\321\277v\373OA*\004\276\277\351\323\201\275\217J\304\277\260\230\021\'\330!\323\277D\003\027\371dw\265?\215\356*\324\225#\266\277\243\304\224\362\263\037\255?;\314\002\306\331\353\314?\346\237dQ\344g\302?\341i`\347\001\264\206?\240\203<\325f\321\301\277j3\251\356\232\372\270\277\004\036\216AX\002\303\277G\302\014\363\234\360\270\277(p\250\027\031\235\272?x\206\352!6\236\260\277\320\367A\225H\360\264?R\375)\r([\315\277\213\256S,\376\227\312\277a\030\351\007x\\\231\277\022\215\326\333-\221\237\277\266\244i\364YQ\240?\2129e\266\230\370\225?\202%\216\001\231\024\310\277\247\"\320\255\2201\240?\214\025\275_\356x\261?>E\317\030\364\263\311?422\251D\244\332\277\367[\007s!\266\305\277r\352~\216\227P\316?\314R\343t\247\330\315?5r;?\317\023\302?A\245\311\311\304\252\315\2776{\367\335\2721\267?\374Y\366u\311\264\222\277\366\013\346\031J\014\324\277d\326\235 \312\005\322\277A\217\370\216\021J\256?M\257\0136\010\362\230?{\021\236F@(\303?\205\232\017o\177\023\321?w\232\267\021c>J?8\r{\206\256\"\323?\250v\033\027\237\370\337?\353h%\000\026{\267\277\360>P\205\272\303\302\277\250D}\2567\235\213\2777)\033\317\372\256\253?o\256&<\321\020\267\277\272 ?ZZ\017Y?\371u\370@nv\214\277\260|\023\355\223\034\310?~8\301\367N\277\275\277\316\304I\006C\263\275?\264U5\177\373\271\215\277\232\303\366\022: \332\277\231\276\260L2h\252\277\374\314T\231Y\262\321?\202\250\354o\201A\270?\000v\323\016^{\263\277[N\003U\255\312\306?>\t\030\346\246f\324?b\361\246&%\252\265?\262\365F\246\003\275\312?\203\2229P\374|\240?\370\371\366\260B\325\220\277\335\001\207\000\n\021\306?\371+\254\321\034\234\313\277S\343\347\234\242V\300\277:\275\306S\265\020\275?\307\376\354\234\340\345\274\277h\353n\3618<\321\277\366\036\234\323\005\323\230\277\247\304\242\364N\347\300\277Et\202\372U\000\304?\245\247szx\n\316\277\301\232\310\3203\022\215?\001\260\204\273IY\246?\220\335=\345z0\275\277Iv?8\035\216\322?}\230\362\257YO\326?F\3507\0211\022\312?\322^\205\336&d\234?\024\333n\376\r7\342?64\341C\343\301\245\277$\275>\264z\366\312\277\302\256\271\226\006\220\207?\301|x!\2171\241\277V#\0336\365/{?\203\006\307\206\333\r\255?\321>\245vm\233\323\277\260\315\315r\312\364\305\2773\324i\200n\352\263\277cv\263\315\377\036\300?Us9\nL(\306?\302\315\033Yc]j?h\323\000\036a\302\304?!hm>\304v\323\277\255\203!\344\t\352\276?\216N.\027\230=\300?\225\\q\246\216>\215\277\272?\341\206a\034\220\277*e\373`:\252\303\277\005\303\010\350\001\014\312\277[j\250>\027\330\277?\201\322\002\366\035\001\266\277A\357\311\177\353\251\275\277\245\264Q\325\360y\221\277\216K9:\003\004\271?dS\254\252\003\303\276\277\033P\"Nh\341\300?\357\023\344\0261\024\252\277YEp\355u\232\270?\032d\275\214\305&\235?\353\356\3651\370\301\205?\360(B\266\367\306\204\277\007[\301\213\247\002\243?\320>\374\037\210!\323\277o.\253\320\336\255\251\277\355\253}`a\335\244?\323\230\367\013\331\224\273?8_\273\360B\031r\277-\t&D\367c\310\277\022B\000((\351\303?\311j\344\'y\345\240\277\313o\270\332\375\263\304?3\363\335z\t4\246?\271\370\305\334\002-\311?\226\374o \305L\322?\313\320Q\364\003\340\301\2771`\210\327SI\270\277\233\371\016\200\016(\267\277\362_\246\020\354\367\210\277z\203n &\342\313\277\007Z\324\005\241(\212?\305\244\214Z\240\n\256\277\344\306\257=\337]\274?\030\026\203\034Q\346\322\2772\205\"\351\343\275\320\277\316\304^\344W\231\252\277\363~\322\310\0326\307\277\033\324X@\360<\253?\300\030\234\2441\272q\277\222g\237\327\236\256\307\277\314Q\270f\320\017\270?~#\205\n\200z\270\277\250\342\314\302\326\033\265\277M=\372E\313W\324?\306\264\322\322\322R\305?\246XZ\024J\"\302?/\031i;\353d\271?\307\332\357\205S\314\261\277\347i\225\267\202\262\275?\017\225\346\354\337\036\270\277>\2736B4\030\310\277QPS`\232\265\306?\237R\t\231\r:\315\277\323\356\253\230\375\250\315\277?Gg\253\312fk?\201f\253\236I\316\322\277\016@\275`\324\004\300\277&Dv\036\263\307\234? \361\210c\2526F?\033c\003Yh&\323\277\202#l\341\344\004\331\277g\244\000\215\336\237\325?\365\273B=|e\300\277\245\376u\230\274:\320\277o\224o\333c\346\257?\211}}B\276G\322\277E\245\377\243\3123\304\277\247\\\352\316\201\260\330\277$o\353k=\023\327\277\246\376\357\217\303\315\346\277\202\326_\341\324\312\262\277d\220C\376\314u\337?t\010\243\326\\>\333\277\377\375+\364&\034\323\277Wa\270C~\024\306\277\236W62v\217\323\277\225\0246\327ZM\330\277\345`\211\324\213e\327\277\346I1\247,\020\316?L\206\200\270\025c\325\277(\370\234\2421\334\306?\207%\240#\035A\270\277\037\325E\n@8\324?\213\016\223\272H\034\265?\200\201\220\254\201h\210\277\257\336\275\223\264o\276?Q =\031\340G\307?\030SX\324\'\002\264?\036X\240~}}\253\277L\242\271\320\013\224\213?\233\335wW\345P\324\277^\3374\334\250\361\315?\177]E\241\326\233\333\277T\370\376\200\372\270\254\277\266y8\344\033r\315?(\321f\206\027\236\325\277l\306\327\346\251\225\273\277&\330\t\367]\235\273\277M;\253\006\204\037\223? i\001\036\261\020\326\277" + } + } + } +} +node { + name: "layer_0_type_0/matrix/read" + op: "Identity" + input: "layer_0_type_0/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_0_type_0/matrix" + } + } + } +} +node { + name: "layer_0_type_0/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "\331*\035}$\365\365\277{5\356\001\217`\305?\215\361>\202\300\027\336\277\2615\215\212\004\241\340?p\301\251E\202\030\340?}lJ\272\277\340\326\277$L4F\225\005\355\277\262\334\023\240\310\177\261?\2454.\331\243\231\247\277z\027\320\227\330\006\375?" + } + } + } +} +node { + name: "layer_0_type_0/bias/read" + op: "Identity" + input: "layer_0_type_0/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_0_type_0/bias" + } + } + } +} +node { + name: "layer_0_type_0/MatMul" + op: "MatMul" + input: "Reshape_15" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "layer_0_type_0/add" + op: "AddV2" + input: "layer_0_type_0/MatMul" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_0_type_0/Tanh" + op: "Tanh" + input: "layer_0_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_0_type_0/Reshape/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "layer_0_type_0/Reshape" + op: "Reshape" + input: "layer_0_type_0/Tanh" + input: "layer_0_type_0/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_1_type_0/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "_U\214g\236^\247?\257T\212\034Q\n\303?\013\303\3462zI\323\277{t\323\231\351~\253\277p\356\344\t\330\257\302?V\007\207\274\r[\224\277\247\222\321\266ow\326?\033\tz\005\307(\311?~\371ar(\002\330\277tr\356`\334\371\302?\341\003_ik\230\305?\024\033\276\277S\014\266\277\016<\373\351\376\235\266\277\331\346\324\251\267\017\253?\346\251\372\227Q\323p\277\322+\273\272\000\313\320?}/a\035si\271\277\356\032\374hH\t\314?\331\262-;\261\351\322?\347E9xV\237\326\277\342\000\272\260\256\034\315?P1I\211?\206\302\277E@rkO\266\327\277\323\323\330\261Q\232\312?\250\306\352\201\177\006\255\2776\333A\371\336\210\232?\320t`\264\221\366\273?\230\353z\270\312V\310\2777\2311\344y\301\333?\355o\033^\025\363\336?\025\377i\204+*\315?\370\233C\r\233\016\260?\240\377\271ANp\303?\321/\024\021\315[\316\277Ll\022\253\234<\321\277]G\021\306mF\324\277\351\001\225\212\017\203\262?\355jB\376x\327\253?\326\202KK\333\"\304\277\027\276\326u\313\t\304\277\274\252\354`\250\220\276\2778\312c;\204\177\252?\355\360v\017\340o\252\277\217\2562\204\261\017\303?\335\201\314j\211\353\330?\263,\313\3574\271\300?\2649\0169\032\224\302?\250Pq\234%\326\316\277\247\333\324\264\347\177\331?G\363$E\305\262\277?S\270\237>J\226\331?O\n\316\0303\372\302\277\253;\320\312\244\305\302\277\277\370\243!\214\204\316\277J\243\247\002T\223\265\277%\230\240\025\207\251\266?\225:\257\374\213\255\312?\343\224\203\014\264\200\267\277\355o\202\274\006\256\300\277e\267\276&\265\254\325?\255\304\031@\376\376\323\277#B\r?t\014\322\277h\214Q\256\034y\233\277\303q\353\302N\350\302\277\000{w\013~\"\233\277\321!\336z@n\340?h\007:\002=\004\306?>\355W\376Y\225\327?\245\232\305k\n\223\274\277L\226\350\250\035\256\325?\350\010\250\264D\246\244\277z\257\250.\344\354\307\277\252\030e\003\177\213\302\277\246\"\335\203\350\021\240?\312\007K\241~v\316?4WH\247O\035\332?r%\236D\205\016\313?\311\224\236\"\230\013\216\277\217\025\t\240\316\017\300\277\036\036C\203\030\r\323?\031\301j\300\\\354\254?\265(\316\375\\\360\272\277\221B\322sG\254\273?\001F\320{\374\312\336\277\266\021&\332(\300\301\277e\316\356\250\316\033\302\277\332\266s0\220-\317?\030\376\001\371\233\244\324?;\320\317\217\270D\300?\306I=.J\002\256?\245\362\000[\364\336\244\277\025\216\241-lB\307?\337\363\366\362\352\354\327?\014r\202\007\274\267\323\277\"\004\031\215l8\342?7\035\254Z\325\317\251\277lq\342\240s\301\324\277\225\272\200\241=\305\214\277WM\376\273\233%\271?\253\027X\000\237\007\342\277" + } + } + } +} +node { + name: "layer_1_type_0/matrix/read" + op: "Identity" + input: "layer_1_type_0/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_1_type_0/matrix" + } + } + } +} +node { + name: "layer_1_type_0/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "\027y%\232\277\034\341\277\034x\206\036\241\007\000\300\314\260\274\'\364m\352\277yP\234\301\r\260\323\277\314$>E+;\357\277\243\245\230\206\205?\001\300\307\222\023&\241Z\354\277\331\331\304\264do\363?\022M\267\234tZ\320\277uN\300\204h4\302\277" + } + } + } +} +node { + name: "layer_1_type_0/bias/read" + op: "Identity" + input: "layer_1_type_0/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_1_type_0/bias" + } + } + } +} +node { + name: "layer_1_type_0/MatMul" + op: "MatMul" + input: "layer_0_type_0/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "layer_1_type_0/add" + op: "AddV2" + input: "layer_1_type_0/MatMul" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_1_type_0/idt" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "\201\001\322\243P\265\303?\r\202\316\273\313s\206\277^\213\005\2412\027\233?\030\246F}\037\270\234?-C\177\232\r\202\234?\025\204\034+\'\216\303?\231\367}\243\2708\305?\347\350z\203\t.\231?J\"\331\356\323\351\256\277\240\372o\265\214w\316?" + } + } + } +} +node { + name: "layer_1_type_0/idt/read" + op: "Identity" + input: "layer_1_type_0/idt" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_1_type_0/idt" + } + } + } +} +node { + name: "layer_1_type_0/Tanh" + op: "Tanh" + input: "layer_1_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_1_type_0/Reshape/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "layer_1_type_0/Reshape" + op: "Reshape" + input: "layer_1_type_0/Tanh" + input: "layer_1_type_0/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_1_type_0/mul" + op: "Mul" + input: "layer_1_type_0/Reshape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "add_5" + op: "AddV2" + input: "layer_0_type_0/Reshape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_2_type_0/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\241\214\256\274dK\273?\361\321\007DqY\253?\272\003\017\364\211d\305\277@w\373)\365\205\257?7$\326E2\030\244\277\341\257GH\024\r\330\277n\276\372\223NU\320?P\271i\310\204]\215?\205\265\263\310\200\301\264?\217\363\304m\353=\337?@\367\312\300\361Y\332?\2366\275(\254\'\273?\320\005:\026\203\225\332?\2059\233\007\021\331\335?*\300~b\204j\311\277\005\275\017\247\372\036\300?9\233\343\310\261\243\252\277\222\016\221\317V\246\303\277C&%\022\374m\334?y\022\025\212\037\277\337\277\351\343L\232\317\025\307?\340\226\033\342\356\235\300\277P\246xaA\264\252\2778\224\357\346\244\307\246?\375G\305B\207\374\273?\346=\271\201d\212\324?\200\"\307\315\303\376\330\277\276\010\343\216\220n\253?\2167\370\2027\004\322?\275\344\023\t\006\232\336?5\345\ts\321\240\300\277!i\035\307!\n\335?\372\n\003\270L\000\314\277\003<\202\326[J\322\277\014\356\215z\324\232\220?`\262\013\220\214\000\276\277H5\217\014\276w\301\277\\\245\230f.\005\342\277\231+\322\177\2041\264?\373\3461w\347b\325\277\217\242-\t\342\027\255\277b\355\030\'\027\364\305\277\316D\005K\311D\202?\177\331\340;\016,\251\277\177\362\344*k\300\325?\t\202+\337\010\263\311\277\261\233\026Y\033\224\305\277<\233\216\230\246\335\321\277\303I\034\306q\216\311\277w\231\010)o:\322\277w\212\301\235\2608\307?\331U\361Q\376\204\226?\035\014vB\344\346\321\277\202\177\331nr\225\325\277\336\232\'^\0378y?\314\237\211\353K\006\307?\310:\360dlt\265?l \310\347%\277\210\277\005L58\3215\275?\033\261\360f\016\307\267?\026&]V\022\242\303?\354\256h\324\310\002\265\277k\353\303\t\311\036\256?\037\350\327\3027 \341\277\327kzU\3523\255?w\341YN\253p\330?\227\223\017\2112\235\301?\205|~\221\007\206\301\277\323\013\336\037\212\026\275?\257\030O\000\006\032\323?\310\362\356\243Y\333\320?\372F43\332\327\323?\017i\223\032eZ\260\277\303\236smX\014\327?\276\363\226\003\365\262\331?\246L\242\242\244\315\351\277h\312_\266\262\270\333\277bZP\363p\004\265\277\316\374>\302\233s\324?I\034\304IL;\220?\260\237*A\324\025\262\277\026f}\366a\023\246\277|\207\210b\t\324\327\277\371q\213\256Pb\312?\212\247\346\253f\267\214\277\237,vd}e\254?\026/\002\322\370?\237?=\210c\2067\277T\2771P\356HpL\244?\262\351\266E\2137\306\2773\'\202\032\373&\312?\034\330\223\333\004}\266\277#dq\234\267\256\303\277\"\304^\002\2150\322\277w\307*\352\352\335\317\277\275~Oo5\036P\277\275\031i\314%d\301\27759\354\230~\331\341\277\267~$\035\226n\276?\260\357q\362\200\326\307\277" + } + } + } +} +node { + name: "layer_2_type_0/matrix/read" + op: "Identity" + input: "layer_2_type_0/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_2_type_0/matrix" + } + } + } +} +node { + name: "layer_2_type_0/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "\316\023\206\255N\276\367\277\213KE\233|\"\352\277\363\377w:\332\366\305?\241v\372c%=\304\277{\'\r\235\177\302\361\277I\344\351@\213\333\326?\311\250dc\236\234\321?\221o<\345\227\226\355?$\3372\265\024b\376?*_\361\006/2\357\277" + } + } + } +} +node { + name: "layer_2_type_0/bias/read" + op: "Identity" + input: "layer_2_type_0/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_2_type_0/bias" + } + } + } +} +node { + name: "layer_2_type_0/MatMul" + op: "MatMul" + input: "add_5" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "layer_2_type_0/add" + op: "AddV2" + input: "layer_2_type_0/MatMul" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_2_type_0/idt" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "\227\362R\322OX\306?(C2g\217\266\243\277\002\337\303\023\224\262\222?\256\025\016\316\014\212\266\277\016\330k\010\373Z\245?\226V%F\235\024\270\277\252\233\202\313\304\026\263\277#nM*\\\202\251\277\350\236\200$\273Y\264?\266\220tHC5\316?" + } + } + } +} +node { + name: "layer_2_type_0/idt/read" + op: "Identity" + input: "layer_2_type_0/idt" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_2_type_0/idt" + } + } + } +} +node { + name: "layer_2_type_0/Tanh" + op: "Tanh" + input: "layer_2_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_2_type_0/Reshape/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "layer_2_type_0/Reshape" + op: "Reshape" + input: "layer_2_type_0/Tanh" + input: "layer_2_type_0/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_2_type_0/mul" + op: "Mul" + input: "layer_2_type_0/Reshape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "add_6" + op: "AddV2" + input: "add_5" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "final_layer_type_0/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\205\342\365\327.Y\334?:\362\024:o\214\234\277#1\356\370\306\n\272?\033v\227Q\232e\341?\206\377\343\333\207\'r\277\212\313\223\245Fz\303?\013O\035\032\017\024\331?\223\014\000\370\222\317\323\277(\273\331Z\033\300\317\277U\312\254\207\\\221\313\277\233\352\033p\336\"\325?\273\270\036fd\377\326?\220L\3718g\361\305\277\331\005\373\272\324x\342\2776\360\254\201\246\232\300?\351o\255\265\303\315\325?\376\033\266\217d\250\331?\034\007\033J\335\n\243?#Y|\267\n\\\311?l\"Jh\321\365\275?\262\262\236\277\n(\321?\372\337\203\305&:\342?\251\353\000\263|d\315?R\241\214\227t\310\331?\250\213\312_n\215\316\277\241C\201\336\033\013\251\277\300tc0\204\r\312?e\254\363\350\3204\211\277\000\022\034\352\213\375\250?\310\307\320U\021\177\303\277\307`\337\271\\\231\327\277\253Ar\036`\233\313\277\262\245\321\205\035\264\320?\272#\010\232TE\320?\214|\256\233\3603\266\277\265T\261*%S\327\277\336\230\302S\034\021\300\277[\340\215\227\017@c\277\203d\372\303ob\301?B\010\253H\350\227\303?\033j\360!F^\331\2775\215e \035\256\342\277tw\241\306\255\223\240\277\232\262S\r\324\014\314\277\341\357bzM\220\216\277=\202\234hO\205\271\277+[\177}\254\327\302?\256\'[a\005O\330\277&\271O5 \212\317?!\313\333,\345\223\321\277\240\205\220\332\222\001\212?\307Q\200\006\253\371\265?~!\314\223Wn\323?\177\3141Tf\273\320?\237V0\245\276\037\307\277\220\273\352\240\375=\267\277\r\0303U\374\205\267\277\005\036\305\314\274\022j?\264\0040W \262\321\2774\")\243\200\316\312?*\363 Q\323\300\307?!FG\032\321\227\267?\316\034-\363\0277\301?}g\263 \004u\314?0\206.\255-#\330\277\262\365\246b\337z\261\277\t\020I\316ts\322\277K\227\370\273H\243\336\277Iop\2471\256\300?\347\243O\315\220\220\260\277\250\005}\232.p\324\277\204\257\023\371\263@\253\277.N\007\246\3708\261\277\302w\316\250n\321\345? \331[d }q?\343\375V\004\205\301\300\277\014\212\020\014\"\345\305\277\035\327\0369\253\303\315?;+\263jS\177\321\277\351\332>\2754&\300?\235\257\266[J2\257\277\341l\336\277\027/\315?p\330\031\024\335\304\216?\211\301{\240x\372\306\277M\037\022\000\255\223\334?\255\313+\377\023m\314\277\3718\205\253\024r\320\277\212\322{\177\001\262\316\277V\251\341\377G\251\330\277\222L\000\320LL\265?\017\272\335{n\002\321?S\233\263)\257\362\240?\262\327\266\317\177\347\300?\031\303\330e\262o\335?\353\276\271x\220\273\302?\320\2103\376\303\353\306\2773z\372\334\367\326\324\277\366\243\325\220\242\356\304?\017\267\374\002\2316\275?\023\266\331&!\360\243\277" + } + } + } +} +node { + name: "final_layer_type_0/matrix/read" + op: "Identity" + input: "final_layer_type_0/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@final_layer_type_0/matrix" + } + } + } +} +node { + name: "final_layer_type_0/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "\242\016;\337\032\225\272?\355\273C6P\341\347?\375\203j\230\023\266\367?%\024\246\363\354q\322?\204\242\321\257\021\371\372\277I\252\302>\340P\363?j\311\321y\254\362\371?\235%(\344\206\366\335\277\2306\2543\006\006\315\277\035mZr\262\372\323\277" + } + } + } +} +node { + name: "final_layer_type_0/bias/read" + op: "Identity" + input: "final_layer_type_0/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@final_layer_type_0/bias" + } + } + } +} +node { + name: "final_layer_type_0/MatMul" + op: "MatMul" + input: "add_6" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "final_layer_type_0/add" + op: "AddV2" + input: "final_layer_type_0/MatMul" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Shape_6" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_26/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_26/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_26/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_26" + op: "StridedSlice" + input: "Shape_6" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_27/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_27/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_27/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_27" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_15" + op: "Mul" + input: "strided_slice_26" + input: "strided_slice_27" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_17/shape/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "Reshape_17/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 10 + } + } + } +} +node { + name: "Reshape_17/shape" + op: "Pack" + input: "mul_15" + input: "Reshape_17/shape/1" + input: "Reshape_17/shape/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_17" + op: "Reshape" + input: "final_layer_type_0/add" + input: "Reshape_17/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "MatMul" + op: "BatchMatMulV2" + input: "Reshape_17" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "Shape_7" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_28/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_28/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_28/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_28" + op: "StridedSlice" + input: "Shape_7" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_29/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_29/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_29/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_29" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Reshape_18/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "Reshape_18/shape" + op: "Pack" + input: "strided_slice_28" + input: "strided_slice_29" + input: "Reshape_18/shape/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_18" + op: "Reshape" + input: "MatMul" + input: "Reshape_18/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_16/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_16" + op: "Mul" + input: "add_4" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_30/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_30/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 4 + } + } + } +} +node { + name: "strided_slice_30/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_30" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_30/stack" + input: "strided_slice_30/stack_1" + input: "strided_slice_30/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_17/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_17" + op: "Mul" + input: "strided_slice_30" + input: "mul_17/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Slice_4/begin/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "Slice_4/begin" + op: "Pack" + input: "Slice_4/begin/0" + input: "mul_16" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_4/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice_4/size" + op: "Pack" + input: "Slice_4/size/0" + input: "mul_17" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_4" + op: "Slice" + input: "Reshape_13" + input: "Slice_4/begin" + input: "Slice_4/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_19/shape" + op: "Const" + 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<\000\000\000" + } + } + } +} +node { + name: "Reshape_19" + op: "Reshape" + input: "Slice_4" + input: "Reshape_19/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_18/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 30 + } + } + } +} +node { + name: "mul_18" + op: "Mul" + input: "add_4" + input: "mul_18/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_31/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_31/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 4 + } + } + } +} +node { + name: "strided_slice_31/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_31" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_31/stack" + input: "strided_slice_31/stack_1" + input: "strided_slice_31/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_19/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 30 + } + } + } +} +node { + name: "mul_19" + op: "Mul" + input: "strided_slice_31" + input: "mul_19/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Slice_5/begin/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "Slice_5/begin" + op: "Pack" + input: "Slice_5/begin/0" + input: "mul_18" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_5/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice_5/size" + op: "Pack" + input: "Slice_5/size/0" + input: "mul_19" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_5" + op: "Slice" + input: "Reshape_14" + input: "Slice_5/begin" + input: "Slice_5/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_20/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\n\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "Reshape_20" + op: "Reshape" + input: "Slice_5" + input: "Reshape_20/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_0_type_1/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 60 + } + dim { + size: 10 + } + } + tensor_content: "\"\000\276A\205\352\232?Y\36514{\216\271?tr\276p\345\201\250?\335\034\276\254\323\347n\277m\205h\320\355\332\201?\223\241\250=\3424\267\277\256\\=\004%\237\240?\204|\":X[\303?\363\002\241\352\342b\302?\263\277^\327(m\304?3\n#\305\346\227\245\277j\n\211z{;\320\277T\372:\016\020U\275\277w\002=\216\205}\266\277)\"\276\240^\036Y?\337\006\331\230\247D\234\277\314\377j\213\273\313\263\277\r\264Tk\333\340\220\2776\352\316@\001J\316\277\353\227!\001Y!\307\277k\327\227\214k\232\302?e\262\230\373\213\244\314?\336\364\253\240\306\311\306?\323\222\340\255\253r\270\2776 \202\270!\211\240?\302X\005\241\031Q\327?\001~\215\336}E\305\277\370$7\211\343\033\306\277\272\354K]qy\303\277\275\340v\335\233u\263\277\233\230r\325\330g\265\277\032\0067\326\220:\333?\341<\222\232\354I\267?\202R\207\374:\331\261?\242\\\004xkG\317\277\2152\346Lmu\330?\360B*\272f(\266?\270P^\313=1\320?%&z3.M\255?\227\245\201\357\232n\310?\022\240;\242\351[\260\277J>XP\371\340\314?\203WNG\217Z\302?e\375\r\274\200J\221?\327\342\207\356\217g\204?\220&\337S\240\366\275?\277E\333=\335\207\240?\373\215j\027N\272\310?f=+e\002V\277?\222\2617\200\210\023\310\277\270\017\343\337\262\332\260\277\372\345\303\363\344\214\300?5\306r\265Ax\272?\200\242j\333\032!\242\277\247\031\320M\365\372\302\277\221\230\002SH)\226?\024\200\301\265\334\324\263?\021\331i/c?\220?P\313u\253\345@\304?a\024\377\310\325\221\302?\261\250\330\333\223\310\310\277\tP&2B\230\305\277\365\325\324^\202\270\247\2771\370\"\037\014\344\277\277\006\t\253\310\304\"\271?\264\032-0#\267\204?\213d\020\230\277\"\013\022\r\342\311p?\005\"\300#P\245\324\277\276\\\202\035[\221\272\277\257\264\322\001A\337\302\277\252E^\273\201\221\254?a\320D\247b\244\275?\243_\275\346\204m\322\277p\022\246\005;>\273\277_O\275\351X\360\220\277uiW\364\333\327\221\277\243\326Py\245[\252?\376M\017\237e\177\300\277r;F\300L\367\263\277\2276Gs\366@\262\277\007zj^$k\246?\267\013\30564\320\260?YN\375\027\335\363\305\277iUY\315\361p\243?\031\357\357\021\021u\307\277\203\372zx{\352\254\277]\241pp(\315\277\277Y\347\026\302?0\356\004\345\335>\320?\010!D\344\177\351\224?\301\263\253\211CF\276\277P\323,c\033\026\207?\277I\025\354\026\026\326\277\'\024\265\017c\324\301\277\240\340\300\2637\025\310\277\013y\236\234*4\204?4\373\004\376\201\024\320\277\256\377\000\362\3558\231?\265y\225!\"\340\243?RxW\006\322h\303\2779\036nD\372\215\240\277\370\231\341\303\211\265\274\277\031\224#\373\243\t\314?\370\270\235K\223\035\235\277\315\330j o^\317?\\z\366\000C\346g?\024\364)\331\037R\300\277\202\002\2548n\342\205\277\\\333\355\227%j\232\277\266\272\265U\330\334\232?\370\355\304\342\225\227\317?M\222\361\004l(\304\277\246t!:t\266\334?\035]o\016\r\362\257?\030q\3650\332\232\207\277\256\313\020r0\303\241\277A\345.\201\256\000\336?}\177\227R\306E\306\277L\335\024\010\247\371\237\277\223\327\361N\357\341\222?C\266.\255\311<\336?\327\245\326ED~\271?{\322\310i\336[\261\277\331\277\306l\004n\277\277+E\364\016\253&\230\2774\232\006\274\317\027\273?)\300\365jXq\313\277\034\024\037\0200\237\305?\037-\325\377ww\313\277\244\311\363\273!\327\276?,\213\006\330\246\340\244?G\212T\025\033\256\260?\200e\021Z\217\006\321?\361\207\256/@\007\274?\027\226[\002Y\340\260\277e\342\336\005m\030\300\277_p\224qt\332\310?%.\255x\223\216\301?\021F8\322R\222\254\277!;&\264s\214\254?/\275\t\344T\200\263\277\nB9\220X\313\252?/\'\214gw\'\310?\317l\256\037\252}\300?\202\371T606\265\277\277\345\274,\234\233\272\277\257\327\316\0263T\266?\021*.J\202R\274?\357\370\373\220\'C\327?\370\342\311G\037_\273?\177\351\323\204\362\352\317?IY\233\375\027\341\225\277m2rR\226\344\300\277U\374\017w\223\227\251\277\214\213i\357O\217\271?\177\257\331\356:\031\214?\3621\321@\036\374\255\277f\366\323\316F\005\256\277f\267)x\003\t\317\277\243\267\265\311:\370\262\277\360\236\353\344\326#\331\277\307\311^\365\362\357\301?|\335\027g\270a\345?\230;\341\227.~\305?\025\0032N\351@R\277\353W\373#\3620\275?x^\315\242%\246\316?\366 \261\266\250\202\272\277\335uL\305\271\375\225?.\366\201\277\010\355\327?\342\203\312\351\'\362\307?\336\361\355\300?\223p\031^&\010\324?\353\241Av\373[\273?\265\037\231o\356\271\300?^\355\351\"\267\242\303\277mq\025\352`\311\242\277\355\r\301X\264`\272?\253i\336<\310\002\254?\321\256\224\351\007\321\302?\305\260\274V\020\250?%\235\375a\033\217\271?\033\302(r99\234\277\373d\203\330gl\226?\247\177\344%\362\312\263\277;\000)\210HS\270?\327\242ZGYA\303\277\270D\354\373T\303\261\277\357D\366\370/\217\262\277\374\373.\225\265\n\301\277\250\021\035}\206f\242?\201/\363\226\364p\241?Y\374\232\372\027\026\301?2\212\306\311a\036\224\277\355t\344\326N\226h?\364\332$2\320<\311\277\264\013p\310\307\311\250?R_\350\323\353g\205?n\333\033\023+\206\315?\r\210}\205@\223\321?\202\224\303\325\262\222\257?\336\313\214h&]\305?\3425\306u\365\033\334?\215\256\270\303$\326\323?\267\031e}S\363\201? \304\242K\243\321\243\277\310|F\222\337I\300?\362\321\345\322\n\027\305?\013\256K\305e\256\302?q\270\204NIW\305?\204-DN\r\247\277?^\221]t\307\017\244?\376X5!o%\255\277\210\300\2035G\010\260?\360\\\247U\001\256\301\277}\371N\352\260\351\313\277#ib\311\267\225\241\277\020~v\222%\217\254?\214\264\201\307l\016\247?4*\343\r!D\201?\201Z\306y+q\275?A\345\302\036?\313\273\277o[;9[\202\276?\001y\215\346K\230\326?\235\211\236&\246\361\260\277^nSS$I\266\2774\233\222J\354\027\301?o\355\366;\343\276\245\277A\256\347\251\332o\322?\240Q\371\211\223\323\260\277Z\345\304rW\356\267?[\240\'\3511\022\273\277\235\026\tT\025\223\263?\223\344\213\253.e\230?\321\213\314\261\330qt\277\025\023\"Ka\233\273\277\350\035\007t\271ip?\017|\314\n\223S\276?\376y\332<\006\213\201?\263\334\333RP\252\306?$\235@\332\207\363\220?.\243u\347i\261\227?\202T\000<\256O\311\277\030tM\225\217!\300\277\305\225\275\340\352\037\260?1\200\350\306\036\215\257\277\025\364\200\223\235\020\246?z\371ZI\250\216\225\277\210{\335\310?\376\303\277\023 5\010aG\255\277\2722\3478n\337\303\277\327~N\3341\323\302\277vL\266\016\000]\312?0\270\033\345\260b\316?\276\235\334\355=\317\261\277\350\246\031\325;u\320\277\235f\227\005-\310\320?q\216\343\002U\220\266\277\204\303]\330\372\374\255?*\227\316A\344u\310?\207\375\\\343$\321\246\2775o\023\343\253\332\306\277\325\230\247D\2641\321?\307QB\224v\275\324?T\240\347^\212n\265?\023\234\002\324\262\263\264\277\2226\206\237#\004\324?\020\016\036\322\024C\314?d\245Fg\"l\276?\034.\374h\332\261\314?\221\261\202\r\333`\331?\004=\347\222\037\373\320?p%\022^\320\300\304?2\370\234y\014\365\303?\345\014A\255\322W\271\277\311T-\347\303}\301\277\276Y>J\240\220\213?\033\253\002\265uq\270?W\220\256\304\362\204\262?\262\371b\264\245j\320?\244\354\352\013W^\254\277q\332\"Sv\272y?SKo\226;\241\331?\023{\207-\321\334\316?\265}I/{\336\256?\260#\346j\256\032\265?{N\255\272v\353\304?\305AG4r1\315\277M;\200\004B\365\261?\215m+%\235\344\327?`e\375F\2151\315?\276\254\177\305\030S\257?\250pO\375W\004\314\277\231F\273\370\306\330\232\277\222d\017\333\356\256\302?\276k9\204G\374\306\277b\'\357+\327V\263?}E\263(\001\275\272?\264\021L\213\211C\321\277\265\246\340\005\254\271\321\277a\277\234\321\307s\306\277\250B\214u@\177\244\277\272 \363\004\234\346\300?_*\326\207k\274\322?\316?\371K:q\231\2776A\265\220\235\024\307\277 w\236X\302\260\271\277`\004\002\361\201\361\275\277\216l\303+u\030\303?\364\302$*\r\314\305?1\032\304\031K\332\322?\370\275\022yp\206\274?6\005\177\226L-\274\277=.\227>\370x\276\277\260b\343\220\306\004\264?\365\241\333\240\337K0\277\3407y\220\372\354\236?\013e\311\032\245y\262?o\372\205\233\363\335\267\277\346\001a\241\240\\\325\277\017JeO\240\022\300\277\\\247\254\020B\333\224?E>\263\032\024\217\307\277\260\236\271}G\002\325\277\031\2161\360n\330\263\277\245\211\254\227\007\365\277\277\351\037{_\307\313\300\277\370\325\312\020>\257\301?u\350<\202\210x\304?\250C[o\311X\273\277\203\026\177\016p*h?j\234Z\235\212\305\317?\365~\245\'\006 \276?\225\302\277\357Z\006_\373I\304\277\023{G\273}\255\260?\325\333\373\231\r%\275?.,\022\345\264-\272\277\202\305k\3662\300\265?\024\273\212\212QS\321\277&\365\270\035\000\002\311?k\363\211\026%]\226\277Rm\024Uq\033\272?\254\227\017\305\305)\226?Io\235\037\265\314\300?\"\335(\331\333\334\237\236?<\021XX\002\202\271\277\025\361\263\203\370H\324?\360,7\265k\311\243\277=\246b\004|\360\266?\354T\254\025-\243\303\277\337\021[B\270\343\266\277,\241p,\211\334\246\277\010\261K\017\253\370\246\277\272\353\361\253\262{\264?=\177@\346\344F\230?h\345\366_\2313\262?\365\032\013p\351n\230?|\031\3125\004;\237\277\262\267&\3321\214\301\277\366\016F\251\026\270\315?\326AFT\344\277\301?%M!\177)\332\323\277\233\275(\267\0132\340?L\262\033`K\331\321?\236`\277\345\221\252s\277\274\'\224\24316\250\277I\344\344?E\220\322?R\3375\006\222\245\322?\036\275\210N_\344\262?\332kE\221\007\224\272?r\367\371\231\223\307\303?\341I\251!\263Q\267?\316S\217\237\312\316\203\277^\306\365\362{X\303?\344\313\025\260}\276\312\277z[l\341\332\317\241\277\225\366#V\241I\254?\024\256\0262,\376\245?8\243f\337\354\213\324\277\363\244\352o\322f\244?\030\200B=\004\201\257?\377\3521I\321\300\321\277\300\257\237\001)B\307?g}d\221\273\202\302?\232\261\311\344G\232\261\27736C\361\241\023\320\277\223n\267\200\370\343\305?\3750\306\375\350\026\204\277\201\215\002~\021\340\260\277<\324\002\232\334\224\243\277=I\344\330B?\320?a\\<\253q\273\270\277F\303zz\261@\243\277V\263J\331\340U\304\277\310N\273\365Iu\260\277m[t\245\346G\251?\367\025\233\\\321\014\260\277j\354\274k\300\303\254\277\324\223\220\035\022&\276?\301h\034\004\206\347W?\274-\\\275\031F\306?\364\027\222\274j\310\251\277;\013;\t_\212\261? g\374[5\010\326\277\002\354\201\027\277B\240?\3462!Nx\275\245?\320\310-\241d\211\261?nu\025^\321\367\312?\352\2605.VN\233\277\361\2325\243\210h\310\277u-\\\034\006\367Y\277\3704Bg\372U~\277\236\334\\\316P\337\323?\360.&\347\350/\310?\227(\002\324|\336\320\277`B\006\237\2100\253\277\201\267\347:\275Q\250?3\236O1\017\231\271\277\205\005F\007\266\341\315?z\321\205\020Mm\311?i\345e^\346\257\321\277\021\342w\265nK\314?\310V\010.\371\241\324?\305\'\254\t\311\023\326?\024\260E\323\201\346\305?\206\262\210::\277\274\277G\335\325\316\306\356\273?U;.\216\311q\313?\005\330Q\202\224\322\304?\345\251\005\027k\317\323?\307\377!\3629\266\275?\330j,\325\n\033\275?\2128^K\212\207\322?2y\354\233\275*\314?\224\213\334\007\361\003\263\277\205\223%n\345I\242\277\025\266\245\340\"D\323?|\\\365K\366%\310?\010#B\376i\361\241?8\335;\177`\244\317?\000\024\302\245M\242\245\277I\276\205\233Ke\244\277h\360fy\332w\313?\304\010\334\307\242\277\324?\253qS\221\226\226\302\277\232\267\276\337f\315{\277\200<\326\225A\203\277?4\227\010!\2667\271?t\321\235\357E\336\274?\312\025%\3158L\322?\213\013%M\366f\300?" + } + } + } +} +node { + name: "layer_0_type_1/matrix/read" + op: "Identity" + input: "layer_0_type_1/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_0_type_1/matrix" + } + } + } +} +node { + name: "layer_0_type_1/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: ".d\241\000|\243\327\277\274y\336\2756\\\343\277\356\031\361E\034\306\352\277c\231\303\210\020\017\353\277\001\252\355J8\035\357?>B\036\033W\207\347\277\247\3576n\272,\341\277\027\270\273\225`B\341?}P\312\021\t\'\320\277\355\326\210\225\341\362\353\277" + } + } + } +} +node { + name: "layer_0_type_1/bias/read" + op: "Identity" + input: "layer_0_type_1/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_0_type_1/bias" + } + } + } +} +node { + name: "layer_0_type_1/MatMul" + op: "MatMul" + input: "Reshape_19" + input: "layer_0_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "layer_0_type_1/add" + op: "AddV2" + input: "layer_0_type_1/MatMul" + input: "layer_0_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_0_type_1/Tanh" + op: "Tanh" + input: "layer_0_type_1/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_0_type_1/Reshape/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "layer_0_type_1/Reshape" + op: "Reshape" + input: "layer_0_type_1/Tanh" + input: "layer_0_type_1/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_1_type_1/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "`\213\254\262\245:\272?CC\366\r\360\322\325\277\273g\rA\323\334\325?\037\r\016\004n\254\324?\007\203]B\310\205\241\277\227U \344?+\332?OVl\035\261\232\325?\345.\027Iuz\304\277:F\202\271\362\037\303?[\373|\362\210\251\207\277\257\ns\355\363\352\347?\3519\371A\324t\334\277e\363\356\252\'\315\341\277n\204\316\322\323A\303\277\2620\030\001\326M\322?\244ro\007?\366\335?n}Et*\263\310\277\000\366\363\332\334F\275\277\227\301Q%\033\264\305\277g\202)\265\332\342\311?\354>\317\362\363D\304?^$F\245\2374\323?\261)\013R[\010\256\277\326:\242\267\037G\323\277\241\256N\234B\320\256\277\205\337\'R\254\377\323?j{\314\342\213B\303?1\277W\213\226\255\242\277\024\021\010\330\275z\301?\371a\343\006<\227\262?!\250\363C\252\322\307\277\253\343j[\250\217\203\277\000\224\300\3774\331\327?\310S:$\342\352\216\277\222\\\341\377yH\323\277%\213\253\224\337\366\254?\253?\200\373q%\265\277\214\3613\352k!\326\277c\007\331\301s\230\313?\223\373\223I pq\277\257\250{^\342\266\253?\240\357\331\241@\320\273?\031\320\016,\336L\271\277\263\232\254P\254-\262?\320\214\212uZ\354\221?\374?&\371\032R\325\277*\241\365(\226\244C\227\271?\366\377\250\223\3206\245\277F/0o\302\353\327\277\260\325\203\216\207X\254?\'M\026\241E\377\271\277J\334\201\305H\031\232\277\201\351+RO\204\323\277\203\024y\234E\025\260?\347\t\345\332\337X\234?h\302\010}\361n\305?\261\355\324c\212\016\324\277\214E\256 \322\035u\277\312Z\351\355w\341s?U\270>\217\342\222\301?c\311\222T\016?\321\277J\323A\302\314Y\300\277\215%\213\365\250\306\317\277\347{d\327\022\251\320\277\270\320\336[\315\210\316\277\376\277\260\203v\306\302?\024\261\0300C\021\323\277\206\376\024PL\356\203?\t\216\262\262\022M\271\277\007\306\214Vj\341~\277$\216\027J\355\326\275\277\036XK\364\024.\330?\326>y\325vH\320?i\225\211nL\311\303\277V\006\"\353M]\321?5\004\036\024\335\306\340?c\245\307\001\353\215\276?\210\252N\351\0041\335\277{\031\361\271\300<\324\277\3216\023\376\242X\304?\217\311\277h\000g\302\2770B!\276xs\322?\214^-\016\317\\\326\277l/cc\305\241\271\277\020\357\200;\227\251\321\277\212>cw\035\362\266\277T\360\353\372ql\266\277\307\302\n\2441P\323\277\232\205kf\305\365\307\277\237\210%\322\006\021\321\277\250\002\301\356B_\277?\n\376\277Bc\\\307\277k\272\177\202l\337\270?8\244-\323*a\303\277" + } + } + } +} +node { + name: "layer_1_type_1/matrix/read" + op: "Identity" + input: "layer_1_type_1/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_1_type_1/matrix" + } + } + } +} +node { + name: "layer_1_type_1/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "[L,\215oq\352\277\316\303\203\3026]\300\277=\276[i\353P\301?\263\344\306\267F\300\372\277\345\371}t\n\307\300?\351\202\322$\010C\361?\033\336\217|\264\025\333\2775\251)\013\227\373\366\277\276\332\255H\333\022\362?4\034\211wnm\350\277" + } + } + } +} +node { + name: "layer_1_type_1/bias/read" + op: "Identity" + input: "layer_1_type_1/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_1_type_1/bias" + } + } + } +} +node { + name: "layer_1_type_1/MatMul" + op: "MatMul" + input: "layer_0_type_1/Reshape" + input: "layer_1_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "layer_1_type_1/add" + op: "AddV2" + input: "layer_1_type_1/MatMul" + input: "layer_1_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_1_type_1/idt" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "e\227\007\013\335\014\312?\003d\2428\224\310\221?8\316E\201\367;\212?|\324\326j\274\340\206?A\241\337]\236\367\274?4\316\'XU\242\266?@\200E\234\005_\263?\215\311\213\276\376/\271?\034\353\357`\356o\302?S\203\363J\330LO?" + } + } + } +} +node { + name: "layer_1_type_1/idt/read" + op: "Identity" + input: "layer_1_type_1/idt" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_1_type_1/idt" + } + } + } +} +node { + name: "layer_1_type_1/Tanh" + op: "Tanh" + input: "layer_1_type_1/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_1_type_1/Reshape/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "layer_1_type_1/Reshape" + op: "Reshape" + input: "layer_1_type_1/Tanh" + input: "layer_1_type_1/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_1_type_1/mul" + op: "Mul" + input: "layer_1_type_1/Reshape" + input: "layer_1_type_1/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "add_8" + op: "AddV2" + input: "layer_0_type_1/Reshape" + input: "layer_1_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_2_type_1/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\260f\236U\236\365\325?\321Q\324\316\211\236\324\277\202\343\312^j&\265\277g\333\334\225kw\304?\231\262).\223\357\251?\n\215\274\324x\025\303?\016\256\352,O\216\276\277\014\004\t\362\354P\320\277\263fgT_\346\301\277F\357p\026E\256\276?\005\223\314\344G\360\263?\226Y\026~\250\331\314\277\331Ru\0311,\314\277u\201\233\303\320\352\246?\261\303\363\270R/\327\277\251\272\375F\303\351o?\363\022\24592\354\267?~\206\356\313\361\367\306\277\371`\247\305\321V\326?\217\027\037\237\345\343\314?v\352\001,\205iv?\031\252\246\373\360\352\322\277\255\224-\001\272\336\303?\335\342\014]c\336`\277tp\255z\2452\303?\036\245=\364\204\027\262\277i-\357\277\323\322\004\204q\322\346?(\217)\317q\177\240\277\374\216\247\204[e\317?5fJ\263\314\266\361?\rfZ\270\355\357\000\300\025\246q\350\257\336\341\277B\016\254\262\260\371\347?D\024\213\260\367\003\344?\253\265\220\017\026.\324?" + } + } + } +} +node { + name: "layer_2_type_1/bias/read" + op: "Identity" + input: "layer_2_type_1/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_2_type_1/bias" + } + } + } +} +node { + name: "layer_2_type_1/MatMul" + op: "MatMul" + input: "add_8" + input: "layer_2_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "layer_2_type_1/add" + op: "AddV2" + input: "layer_2_type_1/MatMul" + input: "layer_2_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_2_type_1/idt" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "\325\332^\373\251Q\306?\330J\200\306\013e\305?\362\026\3741\261\207\222?d\035\351\335j\005\275?\215\031-\267\215\013\301?\027\352\341\021N(\301?\215\264\331:\333=\267?\3775\005<\363<\275?S\372\366*\221\245\200\277l\002\374\355Q\210\206?" + } + } + } +} +node { + name: "layer_2_type_1/idt/read" + op: "Identity" + input: "layer_2_type_1/idt" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_2_type_1/idt" + } + } + } +} +node { + name: "layer_2_type_1/Tanh" + op: "Tanh" + input: "layer_2_type_1/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_2_type_1/Reshape/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "layer_2_type_1/Reshape" + op: "Reshape" + input: "layer_2_type_1/Tanh" + input: "layer_2_type_1/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_2_type_1/mul" + op: "Mul" + input: "layer_2_type_1/Reshape" + input: "layer_2_type_1/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "add_9" + op: "AddV2" + input: "add_8" + input: "layer_2_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "final_layer_type_1/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\253\254\326\214&\030\256\277Twp\032\274k\333\277g\347w&6\242\323?5\277\243D\031\365\246\277\207\016\201\0265\224\232\277_ \005}\245q\326\277}C\375J\345\227\266?vZ\241\325\377\347\313\277rXI\374\305U\256?!K,\352\253Y\277?\211\367\r\235\224d\265\277\344S\341\320\'\r\205\277\211\034\357\300\267\010\230?>\334N\246\321B\330?\253l2\206\275\324\304?:3\365E\330\233\277?\217b1+z\372\322?!K\206\000\337\373\321\277\227\325\236\303\2352\311\277\375?t\255\001I\313?6R\327,\0311\265?\252c\263\363\262\034\322\277\247\327\344\030:\n\304?)\004\016\274O\350\320?\322\364\003\010X\353\312?\333R\273\\\344\247B?TA\211{\'\177\247?\036;j=\351\231\235\277?\300\"U\361+\270?\334\346\t\003\200J\267\277\304\264\257\023\251<\277?\266\245\267\273\320 \304?\230\355P\2775?\312?\350\312S 5\034\241\277p\264\215g2!\313\277]4$\024\340}\301?[:\2553\'\223\327\277`\23261\241)\313?\036\257\341\262Z\266E?\n\254\331\220\355=\327?\230(f3\330\366\307\277\334\261a\304J`\342?<{\"u\303\223\311\277\007o\010nW\313\322\2772\2624\225wJ\333?\317\004\346\226{\313\300?\031\300\360\032\004\324\310?\030[\247\034=;\332?W\333\334\n\347u\332\277\270Q\215z\302\237\313?d\331\357\212\354\246\260\277\326\340\375\03174\262\277\025\343\344\r\331\247\323?j\246\003\222\346\351\265?\346\350\360\315n\343\316?\307\264\253\336\315\031\300?\365BA\310\376{\257\277\325\247(<.}\262\277\245\321;\2054\353\263?J\344\275d\340h\260?y\031\265\017\312\271\264?\377\373b\"\220\211\240\277\323\301\223\305\307\244\235\277\005?\364i\336\254\331\277\270\357\227kyR\310?Kb_fB#\327?\341\313\3152W\277\331?\264\332\264\005\007\022\303\277W\230:\033Z\205\333?6\3534u\002\223\307\277`\301\226b\241\341\343?A\243\312\372\256\273\320\2777\345w\320\303\211\320\277\264e\025\353\3521\330\277\315Sx\"\310\315\277?\361\262\305\316\021\022\203\277\277\307g\'\210\315\245?%1_?\261\351\243\277\3233zh\177\t\317\277\236\\\031N\216y\334\277e\002]\233UGv\277\235\247\001JS,\247?\031\025\224\316\207\214\320?9A\355R:u\263?\227\244\320\"\377>\311?\033B\016_!\025\312?\315\275\321\252\245\230\331?\027[\017p\310)\270?\332\314;N\367\276\303\277\311\320\267\223\360\340\270?\2560cw\333\303f\277\005\367\001\006E$\312?\272N\331\307\273\360\300?60\367\250\367\340\233\277\'y\351V\333D\277\277M\223\333\317\217\n\332?\356\265\254\325M7\317\277\226\215\323\262\322\263\262\277\001\343\350\200+s\254\277\360\314\305UIj\272?" + } + } + } +} +node { + name: "final_layer_type_1/matrix/read" + op: "Identity" + input: "final_layer_type_1/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@final_layer_type_1/matrix" + } + } + } +} +node { + name: "final_layer_type_1/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "Q\327\305\237v\244\370\277\273\nW;\205\035\371\277sm\344\337\024\325\320\277?#\026\233\251\273\347\277\345\274\014\271^\225\331\277Yj\022X\0257\366\277\215u\354b\356\335\352\277Bs(\203\335~\352?1\356H@\377\351\340?\350\345i2\021\277\324?" + } + } + } +} +node { + name: "final_layer_type_1/bias/read" + op: "Identity" + input: "final_layer_type_1/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@final_layer_type_1/bias" + } + } + } +} +node { + name: "final_layer_type_1/MatMul" + op: "MatMul" + input: "add_9" + input: "final_layer_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "final_layer_type_1/add" + op: "AddV2" + input: "final_layer_type_1/MatMul" + input: "final_layer_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Shape_8" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_33/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_33/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_33/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_33" + op: "StridedSlice" + input: "Shape_8" + input: "strided_slice_33/stack" + input: "strided_slice_33/stack_1" + input: "strided_slice_33/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_34/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_34/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 4 + } + } + } +} +node { + name: "strided_slice_34/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_34" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_34/stack" + input: "strided_slice_34/stack_1" + input: "strided_slice_34/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_20" + op: "Mul" + input: "strided_slice_33" + input: "strided_slice_34" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_21/shape/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "Reshape_21/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 10 + } + } + } +} +node { + name: "Reshape_21/shape" + op: "Pack" + input: "mul_20" + input: "Reshape_21/shape/1" + input: "Reshape_21/shape/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_21" + op: "Reshape" + input: "final_layer_type_1/add" + input: "Reshape_21/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_21" + input: "Reshape_20" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "Shape_9" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_35/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_35/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_35/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_35" + op: "StridedSlice" + input: "Shape_9" + input: "strided_slice_35/stack" + input: "strided_slice_35/stack_1" + input: "strided_slice_35/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_36/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_36/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 4 + } + } + } +} +node { + name: "strided_slice_36/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_36" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_36/stack" + input: "strided_slice_36/stack_1" + input: "strided_slice_36/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Reshape_22/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "Reshape_22/shape" + op: "Pack" + input: "strided_slice_35" + input: "strided_slice_36" + input: "Reshape_22/shape/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_22" + op: "Reshape" + input: "MatMul_1" + input: "Reshape_22/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "concat_2/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "concat_2" + op: "ConcatV2" + input: "Reshape_18" + input: "Reshape_22" + input: "concat_2/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_23/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_23" + op: "Reshape" + input: "concat_2" + input: "Reshape_23/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_21/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_21" + op: "Mul" + input: "add_1" + input: "mul_21/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "o_dipole/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "o_dipole/shape" + op: "Pack" + input: "o_dipole/shape/0" + input: "mul_21" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "o_dipole" + op: "Reshape" + input: "Reshape_23" + input: "o_dipole/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_24/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_24/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "Reshape_24/shape" + op: "Pack" + input: "Reshape_24/shape/0" + input: "add_1" + input: "Reshape_24/shape/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_24" + op: "Reshape" + input: "o_dipole" + input: "Reshape_24/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Sum/reduction_indices" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "Sum" + op: "Sum" + input: "Reshape_24" + input: "Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "o_global_dipole/shape" + op: "Const" + 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: "o_global_dipole" + op: "Reshape" + input: "Sum" + input: "o_global_dipole/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "split/split_dim" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "split" + op: "Split" + input: "split/split_dim" + input: "Reshape_24" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "num_split" + value { + i: 3 + } + } +} +node { + name: "gradients/Shape" + op: "Shape" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients/grad_ys_0" + op: "Fill" + input: "gradients/Shape" + input: "gradients/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/zeros_like" + op: "ZerosLike" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/zeros_like_1" + op: "ZerosLike" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/split_grad/concat" + op: "ConcatV2" + input: "gradients/grad_ys_0" + input: "gradients/zeros_like" + input: "gradients/zeros_like_1" + input: "split/split_dim" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_24_grad/Shape" + op: "Shape" + input: "o_dipole" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_24_grad/Reshape" + op: "Reshape" + input: "gradients/split_grad/concat" + input: "gradients/Reshape_24_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/o_dipole_grad/Shape" + op: "Shape" + input: "Reshape_23" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/o_dipole_grad/Reshape" + op: "Reshape" + input: "gradients/Reshape_24_grad/Reshape" + input: "gradients/o_dipole_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_23_grad/Shape" + op: "Shape" + input: "concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_23_grad/Reshape" + op: "Reshape" + input: "gradients/o_dipole_grad/Reshape" + input: "gradients/Reshape_23_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients/concat_2_grad/mod" + op: "FloorMod" + input: "concat_2/axis" + input: "gradients/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_2_grad/ShapeN" + op: "ShapeN" + input: "Reshape_18" + input: "Reshape_22" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/concat_2_grad/mod" + input: "gradients/concat_2_grad/ShapeN" + input: "gradients/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/concat_2_grad/Slice" + op: "Slice" + input: "gradients/Reshape_23_grad/Reshape" + input: "gradients/concat_2_grad/ConcatOffset" + input: "gradients/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients/Reshape_23_grad/Reshape" + input: "gradients/concat_2_grad/ConcatOffset:1" + input: "gradients/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients/concat_2_grad/Slice" + input: "gradients/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_22_grad/Shape" + op: "Shape" + input: "MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients/concat_2_grad/Slice_1" + input: "gradients/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients/Reshape_18_grad/Reshape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_17" + input: "gradients/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients/MatMul_grad/Shape" + input: "gradients/MatMul_grad/strided_slice/stack" + input: "gradients/MatMul_grad/strided_slice/stack_1" + input: "gradients/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/MatMul_grad/Shape_1" + input: "gradients/MatMul_grad/strided_slice_1/stack" + input: "gradients/MatMul_grad/strided_slice_1/stack_1" + input: "gradients/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/MatMul_grad/strided_slice" + input: "gradients/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/Sum" + op: "Sum" + input: "gradients/MatMul_grad/MatMul" + input: "gradients/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients/MatMul_grad/Sum" + input: "gradients/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients/MatMul_grad/MatMul_1" + input: "gradients/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients/MatMul_grad/Sum_1" + input: "gradients/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_1_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients/Reshape_22_grad/Reshape" + input: "Reshape_20" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/MatMul_1_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_21" + input: "gradients/Reshape_22_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_1_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_1_grad/Shape_1" + op: "Shape" + input: "Reshape_20" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_1_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/MatMul_1_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/MatMul_1_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/MatMul_1_grad/strided_slice" + op: "StridedSlice" + input: "gradients/MatMul_1_grad/Shape" + input: "gradients/MatMul_1_grad/strided_slice/stack" + input: "gradients/MatMul_1_grad/strided_slice/stack_1" + input: "gradients/MatMul_1_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/MatMul_1_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/MatMul_1_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/MatMul_1_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/MatMul_1_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/MatMul_1_grad/Shape_1" + input: "gradients/MatMul_1_grad/strided_slice_1/stack" + input: "gradients/MatMul_1_grad/strided_slice_1/stack_1" + input: "gradients/MatMul_1_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/MatMul_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/MatMul_1_grad/strided_slice" + input: "gradients/MatMul_1_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_1_grad/Sum" + op: "Sum" + input: "gradients/MatMul_1_grad/MatMul" + input: "gradients/MatMul_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_1_grad/Reshape" + op: "Reshape" + input: "gradients/MatMul_1_grad/Sum" + input: "gradients/MatMul_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_1_grad/Sum_1" + op: "Sum" + input: "gradients/MatMul_1_grad/MatMul_1" + input: "gradients/MatMul_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_1_grad/Reshape_1" + op: "Reshape" + input: "gradients/MatMul_1_grad/Sum_1" + input: "gradients/MatMul_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients/MatMul_grad/Reshape" + input: "gradients/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients/MatMul_grad/Reshape_1" + input: "gradients/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_21_grad/Shape" + op: "Shape" + input: "final_layer_type_1/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients/MatMul_1_grad/Reshape" + input: "gradients/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_20_grad/Shape" + op: "Shape" + input: "Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_20_grad/Reshape" + op: "Reshape" + input: "gradients/MatMul_1_grad/Reshape_1" + input: "gradients/Reshape_20_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/final_layer_type_0/add_grad/Shape" + input: "gradients/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/Reshape_17_grad/Reshape" + input: "gradients/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/final_layer_type_0/add_grad/Sum" + input: "gradients/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_3_grad/stack" + op: "Pack" + input: "gradients/Slice_3_grad/Rank" + input: "gradients/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/sub" + op: "Sub" + input: "gradients/Slice_3_grad/Shape_1" + input: "gradients/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/Slice_3_grad/sub_1" + input: "gradients/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients/Slice_3_grad/Reshape" + input: "gradients/Slice_3_grad/Reshape_1" + input: "gradients/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 + } + } +} +node { + name: "gradients/Slice_3_grad/Pad" + op: "Pad" + input: "gradients/Reshape_16_grad/Reshape" + input: "gradients/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_1/add_grad/Shape" + op: "Shape" + input: "final_layer_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_1/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/final_layer_type_1/add_grad/Shape" + input: "gradients/final_layer_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_1/add_grad/Sum" + op: "Sum" + input: "gradients/Reshape_21_grad/Reshape" + input: "gradients/final_layer_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/final_layer_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients/final_layer_type_1/add_grad/Sum" + input: "gradients/final_layer_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/Slice_5_grad/Shape" + op: "Shape" + input: "Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_5_grad/stack" + op: "Pack" + input: "gradients/Slice_5_grad/Rank" + input: "gradients/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/Slice_5_grad/Reshape" + op: "Reshape" + input: "Slice_5/begin" + input: "gradients/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_5_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_5_grad/sub" + op: "Sub" + input: "gradients/Slice_5_grad/Shape_1" + input: "gradients/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients/Slice_5_grad/sub" + input: "Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients/Slice_5_grad/sub_1" + input: "gradients/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients/Slice_5_grad/Reshape" + input: "gradients/Slice_5_grad/Reshape_1" + input: "gradients/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 + } + } +} +node { + name: "gradients/Slice_5_grad/Pad" + op: "Pad" + input: "gradients/Reshape_20_grad/Reshape" + input: "gradients/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/final_layer_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/final_layer_type_1/add_grad/Reshape" + input: "final_layer_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/AddN" + op: "AddN" + input: "gradients/Slice_3_grad/Pad" + input: "gradients/Slice_5_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/Slice_3_grad/Pad" + } + } + } +} +node { + name: "gradients/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients/AddN" + input: "gradients/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_6_grad/Shape" + op: "Shape" + input: "add_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_6_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/add_6_grad/Shape" + input: "gradients/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_6_grad/Sum" + op: "Sum" + input: "gradients/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_6_grad/Reshape" + op: "Reshape" + input: "gradients/add_6_grad/Sum" + input: "gradients/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_6_grad/Sum_1" + op: "Sum" + input: "gradients/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients/add_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_6_grad/Reshape_1" + op: "Reshape" + input: "gradients/add_6_grad/Sum_1" + input: "gradients/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_9_grad/Shape" + op: "Shape" + input: "add_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_9_grad/Shape_1" + op: "Shape" + input: "layer_2_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/add_9_grad/Shape" + input: "gradients/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_9_grad/Sum" + op: "Sum" + input: "gradients/final_layer_type_1/MatMul_grad/MatMul" + input: "gradients/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_9_grad/Reshape" + op: "Reshape" + input: "gradients/add_9_grad/Sum" + input: "gradients/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_9_grad/Sum_1" + op: "Sum" + input: "gradients/final_layer_type_1/MatMul_grad/MatMul" + input: "gradients/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients/add_9_grad/Sum_1" + input: "gradients/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_2_type_0/mul_grad/Shape" + input: "gradients/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients/add_6_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients/layer_2_type_0/mul_grad/Mul" + input: "gradients/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients/layer_2_type_0/mul_grad/Sum" + input: "gradients/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_1/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_1/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_1/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_2_type_1/mul_grad/Shape" + input: "gradients/layer_2_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients/add_9_grad/Reshape_1" + input: "layer_2_type_1/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_2_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients/layer_2_type_1/mul_grad/Mul" + input: "gradients/layer_2_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_2_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients/layer_2_type_1/mul_grad/Sum" + input: "gradients/layer_2_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/concat_1_grad/mod" + input: "gradients/concat_1_grad/ShapeN" + input: "gradients/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/concat_1_grad/Slice" + op: "Slice" + input: "gradients/Reshape_14_grad/Reshape" + input: "gradients/concat_1_grad/ConcatOffset" + input: "gradients/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients/Reshape_14_grad/Reshape" + input: "gradients/concat_1_grad/ConcatOffset:1" + input: "gradients/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/layer_2_type_0/mul_grad/Reshape" + input: "gradients/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_1/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/layer_2_type_1/mul_grad/Reshape" + input: "gradients/layer_2_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients/concat_1_grad/Slice" + input: "gradients/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients/concat_1_grad/Slice_1" + input: "gradients/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_2_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_1/Tanh" + input: "gradients/layer_2_type_1/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients/Reshape_8_grad/Reshape" + input: "gradients/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients/Reshape_12_grad/Reshape" + input: "gradients/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_2_type_0/add_grad/Shape" + input: "gradients/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/layer_2_type_0/add_grad/Sum" + input: "gradients/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_1/add_grad/Shape" + op: "Shape" + input: "layer_2_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_1/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_2_type_1/add_grad/Shape" + input: "gradients/layer_2_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_1/add_grad/Sum" + op: "Sum" + input: "gradients/layer_2_type_1/Tanh_grad/TanhGrad" + input: "gradients/layer_2_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_2_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients/layer_2_type_1/add_grad/Sum" + input: "gradients/layer_2_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_5_grad/Rank" + input: "gradients/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_5_grad/sub_1" + input: "gradients/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_5_grad/Reshape" + input: "gradients/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients/filter_type_0/transpose_grad/transpose" + input: "gradients/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_5_grad/Rank" + input: "gradients/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_5_grad/sub_1" + input: "gradients/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_5_grad/Reshape" + input: "gradients/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients/filter_type_1/transpose_grad/transpose" + input: "gradients/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/layer_2_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/layer_2_type_1/add_grad/Reshape" + input: "layer_2_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/AddN_1" + op: "AddN" + input: "gradients/add_6_grad/Reshape" + input: "gradients/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/add_6_grad/Reshape" + } + } + } +} +node { + name: "gradients/add_5_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_5_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/add_5_grad/Shape" + input: "gradients/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_5_grad/Sum" + op: "Sum" + input: "gradients/AddN_1" + input: "gradients/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_5_grad/Reshape" + op: "Reshape" + input: "gradients/add_5_grad/Sum" + input: "gradients/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_5_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_1" + input: "gradients/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients/add_5_grad/Sum_1" + input: "gradients/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_2" + op: "AddN" + input: "gradients/add_9_grad/Reshape" + input: "gradients/layer_2_type_1/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients/add_8_grad/Shape" + op: "Shape" + input: "layer_0_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_8_grad/Shape_1" + op: "Shape" + input: "layer_1_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/add_8_grad/Shape" + input: "gradients/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_8_grad/Sum" + op: "Sum" + input: "gradients/AddN_2" + input: "gradients/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_8_grad/Reshape" + op: "Reshape" + input: "gradients/add_8_grad/Sum" + input: "gradients/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_8_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_2" + input: "gradients/add_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_8_grad/Reshape_1" + op: "Reshape" + input: "gradients/add_8_grad/Sum_1" + input: "gradients/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_1_type_0/mul_grad/Shape" + input: "gradients/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients/add_5_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients/layer_1_type_0/mul_grad/Mul" + input: "gradients/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients/layer_1_type_0/mul_grad/Sum" + input: "gradients/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_1/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_1/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_1/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_1_type_1/mul_grad/Shape" + input: "gradients/layer_1_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients/add_8_grad/Reshape_1" + input: "layer_1_type_1/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_1_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients/layer_1_type_1/mul_grad/Mul" + input: "gradients/layer_1_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_1_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients/layer_1_type_1/mul_grad/Sum" + input: "gradients/layer_1_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/layer_1_type_0/mul_grad/Reshape" + input: "gradients/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_1/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/layer_1_type_1/mul_grad/Reshape" + input: "gradients/layer_1_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_1_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_1/Tanh" + input: "gradients/layer_1_type_1/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_1_type_0/add_grad/Shape" + input: "gradients/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/layer_1_type_0/add_grad/Sum" + input: "gradients/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_1/add_grad/Shape" + op: "Shape" + input: "layer_1_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_1/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_1_type_1/add_grad/Shape" + input: "gradients/layer_1_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_1/add_grad/Sum" + op: "Sum" + input: "gradients/layer_1_type_1/Tanh_grad/TanhGrad" + input: "gradients/layer_1_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_1_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients/layer_1_type_1/add_grad/Sum" + input: "gradients/layer_1_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/layer_1_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/layer_1_type_1/add_grad/Reshape" + input: "layer_1_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/AddN_3" + op: "AddN" + input: "gradients/add_5_grad/Reshape" + input: "gradients/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_3" + input: "gradients/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_4" + op: "AddN" + input: "gradients/add_8_grad/Reshape" + input: "gradients/layer_1_type_1/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/add_8_grad/Reshape" + } + } + } +} +node { + name: "gradients/layer_0_type_1/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_4" + input: "gradients/layer_0_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_0_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_1/Tanh" + input: "gradients/layer_0_type_1/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_0_type_0/add_grad/Shape" + input: "gradients/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/layer_0_type_0/add_grad/Sum" + input: "gradients/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_1/add_grad/Shape" + op: "Shape" + input: "layer_0_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_1/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_0_type_1/add_grad/Shape" + input: "gradients/layer_0_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_1/add_grad/Sum" + op: "Sum" + input: "gradients/layer_0_type_1/Tanh_grad/TanhGrad" + input: "gradients/layer_0_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_0_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients/layer_0_type_1/add_grad/Sum" + input: "gradients/layer_0_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/layer_0_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/layer_0_type_1/add_grad/Reshape" + input: "layer_0_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_19_grad/Shape" + op: "Shape" + input: "Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_19_grad/Reshape" + op: "Reshape" + input: "gradients/layer_0_type_1/MatMul_grad/MatMul" + input: "gradients/Reshape_19_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_2_grad/stack" + op: "Pack" + input: "gradients/Slice_2_grad/Rank" + input: "gradients/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/sub" + op: "Sub" + input: "gradients/Slice_2_grad/Shape_1" + input: "gradients/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/Slice_2_grad/sub_1" + input: "gradients/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients/Slice_2_grad/Reshape" + input: "gradients/Slice_2_grad/Reshape_1" + input: "gradients/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 + } + } +} +node { + name: "gradients/Slice_2_grad/Pad" + op: "Pad" + input: "gradients/Reshape_15_grad/Reshape" + input: "gradients/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/Slice_4_grad/Shape" + op: "Shape" + input: "Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_4_grad/stack" + op: "Pack" + input: "gradients/Slice_4_grad/Rank" + input: "gradients/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/Slice_4_grad/Reshape" + op: "Reshape" + input: "Slice_4/begin" + input: "gradients/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_4_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_4_grad/sub" + op: "Sub" + input: "gradients/Slice_4_grad/Shape_1" + input: "gradients/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients/Slice_4_grad/sub" + input: "Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/Slice_4_grad/sub_1" + input: "gradients/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients/Slice_4_grad/Reshape" + input: "gradients/Slice_4_grad/Reshape_1" + input: "gradients/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 + } + } +} +node { + name: "gradients/Slice_4_grad/Pad" + op: "Pad" + input: "gradients/Reshape_19_grad/Reshape" + input: "gradients/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_5" + op: "AddN" + input: "gradients/Slice_2_grad/Pad" + input: "gradients/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/Slice_2_grad/Pad" + } + } + } +} +node { + name: "gradients/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_5" + input: "gradients/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/concat_grad/mod" + input: "gradients/concat_grad/ShapeN" + input: "gradients/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/concat_grad/Slice" + op: "Slice" + input: "gradients/Reshape_13_grad/Reshape" + input: "gradients/concat_grad/ConcatOffset" + input: "gradients/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/concat_grad/Slice_1" + op: "Slice" + input: "gradients/Reshape_13_grad/Reshape" + input: "gradients/concat_grad/ConcatOffset:1" + input: "gradients/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients/concat_grad/Slice" + input: "gradients/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients/concat_grad/Slice_1" + input: "gradients/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients/Reshape_7_grad/Reshape" + input: "gradients/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients/Reshape_11_grad/Reshape" + input: "gradients/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_8_grad/Shape" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_8_grad/Sum" + input: "gradients/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_8_grad/Shape" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_8_grad/Sum" + input: "gradients/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_4_grad/Rank" + input: "gradients/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_4_grad/sub_1" + input: "gradients/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_4_grad/Reshape" + input: "gradients/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_4_grad/Rank" + input: "gradients/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_4_grad/sub_1" + input: "gradients/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_4_grad/Reshape" + input: "gradients/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_6" + op: "AddN" + input: "gradients/filter_type_0/Slice_5_grad/Pad" + input: "gradients/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/mul_grad/Shape" + input: "gradients/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients/AddN_6" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/mul_grad/Mul" + input: "gradients/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/mul_grad/Sum" + input: "gradients/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_7" + op: "AddN" + input: "gradients/filter_type_1/Slice_5_grad/Pad" + input: "gradients/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/mul_grad/Shape" + input: "gradients/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients/AddN_7" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/mul_grad/Mul" + input: "gradients/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/mul_grad/Sum" + input: "gradients/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_10_grad/Shape" + input: "gradients/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/mul_grad/Reshape" + input: "gradients/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_10_grad/Sum" + input: "gradients/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/mul_grad/Reshape" + input: "gradients/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_10_grad/Sum_1" + input: "gradients/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_10_grad/Shape" + input: "gradients/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/mul_grad/Reshape" + input: "gradients/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_10_grad/Sum" + input: "gradients/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/mul_grad/Reshape" + input: "gradients/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_10_grad/Sum_1" + input: "gradients/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_3_grad/Shape" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_3_grad/Sum" + input: "gradients/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_7_grad/Shape" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_7_grad/Sum" + input: "gradients/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_3_grad/Shape" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_3_grad/Sum" + input: "gradients/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_7_grad/Shape" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_7_grad/Sum" + input: "gradients/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/add_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_4_grad/Shape" + input: "gradients/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_4_grad/Sum" + input: "gradients/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_4_grad/Sum_1" + input: "gradients/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_9_grad/Shape" + input: "gradients/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_9_grad/Sum" + input: "gradients/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_9_grad/Sum_1" + input: "gradients/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/add_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_4_grad/Shape" + input: "gradients/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_4_grad/Sum" + input: "gradients/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_4_grad/Sum_1" + input: "gradients/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_9_grad/Shape" + input: "gradients/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_9_grad/Sum" + input: "gradients/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_9_grad/Sum_1" + input: "gradients/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_4_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_9_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_4_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_9_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_3_grad/Shape" + input: "gradients/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_3_grad/Sum" + input: "gradients/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_8_grad/Shape" + input: "gradients/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_8_grad/Sum" + input: "gradients/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_3_grad/Shape" + input: "gradients/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_3_grad/Sum" + input: "gradients/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_8_grad/Shape" + input: "gradients/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_8_grad/Sum" + input: "gradients/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/AddN_8" + op: "AddN" + input: "gradients/filter_type_0/add_4_grad/Reshape" + input: "gradients/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_2_grad/Shape" + input: "gradients/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients/AddN_8" + input: "gradients/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_2_grad/Sum" + input: "gradients/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_8" + input: "gradients/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_2_grad/Sum_1" + input: "gradients/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_9" + op: "AddN" + input: "gradients/filter_type_0/add_9_grad/Reshape" + input: "gradients/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_7_grad/Shape" + input: "gradients/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients/AddN_9" + input: "gradients/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_7_grad/Sum" + input: "gradients/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_9" + input: "gradients/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_7_grad/Sum_1" + input: "gradients/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_10" + op: "AddN" + input: "gradients/filter_type_1/add_4_grad/Reshape" + input: "gradients/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_2_grad/Shape" + input: "gradients/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients/AddN_10" + input: "gradients/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_2_grad/Sum" + input: "gradients/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_10" + input: "gradients/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_2_grad/Sum_1" + input: "gradients/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_11" + op: "AddN" + input: "gradients/filter_type_1/add_9_grad/Reshape" + input: "gradients/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_7_grad/Shape" + input: "gradients/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients/AddN_11" + input: "gradients/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_7_grad/Sum" + input: "gradients/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_11" + input: "gradients/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_7_grad/Sum_1" + input: "gradients/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_2_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_7_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_2_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_7_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_1_grad/Shape" + input: "gradients/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_1_grad/Sum" + input: "gradients/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_6_grad/Shape" + input: "gradients/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_6_grad/Sum" + input: "gradients/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_1_grad/Shape" + input: "gradients/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_1_grad/Sum" + input: "gradients/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_6_grad/Shape" + input: "gradients/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_6_grad/Sum" + input: "gradients/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/AddN_12" + op: "AddN" + input: "gradients/filter_type_0/add_2_grad/Reshape" + input: "gradients/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/add_2_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_12" + input: "gradients/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_13" + op: "AddN" + input: "gradients/filter_type_0/add_7_grad/Reshape" + input: "gradients/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/add_7_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_13" + input: "gradients/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_14" + op: "AddN" + input: "gradients/filter_type_1/add_2_grad/Reshape" + input: "gradients/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/add_2_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_14" + input: "gradients/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_15" + op: "AddN" + input: "gradients/filter_type_1/add_7_grad/Reshape" + input: "gradients/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/add_7_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_15" + input: "gradients/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_grad/Shape" + input: "gradients/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_grad/Sum" + input: "gradients/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_5_grad/Shape" + input: "gradients/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_5_grad/Sum" + input: "gradients/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_grad/Shape" + input: "gradients/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_grad/Sum" + input: "gradients/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_5_grad/Shape" + input: "gradients/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_5_grad/Sum" + input: "gradients/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_grad/MatMul" + input: "gradients/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_grad/MatMul" + input: "gradients/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_1_grad/Rank" + input: "gradients/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_1_grad/sub_1" + input: "gradients/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_1_grad/Reshape" + input: "gradients/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_3_grad/Rank" + input: "gradients/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_3_grad/sub_1" + input: "gradients/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_3_grad/Reshape" + input: "gradients/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_1_grad/Rank" + input: "gradients/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_1_grad/sub_1" + input: "gradients/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_1_grad/Reshape" + input: "gradients/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_3_grad/Rank" + input: "gradients/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_3_grad/sub_1" + input: "gradients/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_3_grad/Reshape" + input: "gradients/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/Slice_1_grad/Pad" + input: "gradients/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/Slice_3_grad/Pad" + input: "gradients/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/Slice_1_grad/Pad" + input: "gradients/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/Slice_3_grad/Pad" + input: "gradients/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_16" + op: "AddN" + input: "gradients/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_grad/Rank" + input: "gradients/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_grad/Shape_1" + input: "gradients/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_grad/sub_1" + input: "gradients/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_grad/Reshape" + input: "gradients/filter_type_0/Slice_grad/Reshape_1" + input: "gradients/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients/AddN_16" + input: "gradients/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_17" + op: "AddN" + input: "gradients/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_2_grad/Rank" + input: "gradients/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_2_grad/sub_1" + input: "gradients/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_2_grad/Reshape" + input: "gradients/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients/AddN_17" + input: "gradients/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_18" + op: "AddN" + input: "gradients/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_grad/Rank" + input: "gradients/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_grad/Shape_1" + input: "gradients/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_grad/sub_1" + input: "gradients/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_grad/Reshape" + input: "gradients/filter_type_1/Slice_grad/Reshape_1" + input: "gradients/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients/AddN_18" + input: "gradients/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_19" + op: "AddN" + input: "gradients/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_2_grad/Rank" + input: "gradients/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_2_grad/sub_1" + input: "gradients/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_2_grad/Reshape" + input: "gradients/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients/AddN_19" + input: "gradients/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_20" + op: "AddN" + input: "gradients/filter_type_0/Slice_grad/Pad" + input: "gradients/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_20" + input: "gradients/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_21" + op: "AddN" + input: "gradients/filter_type_1/Slice_grad/Pad" + input: "gradients/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_21" + input: "gradients/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_grad/stack" + op: "Pack" + input: "gradients/Slice_grad/Rank" + input: "gradients/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/sub" + op: "Sub" + input: "gradients/Slice_grad/Shape_1" + input: "gradients/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/sub_1" + op: "Sub" + input: "gradients/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients/Slice_grad/sub_1" + input: "gradients/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_grad/concat" + op: "ConcatV2" + input: "gradients/Slice_grad/Reshape" + input: "gradients/Slice_grad/Reshape_1" + input: "gradients/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/Pad" + op: "Pad" + input: "gradients/Reshape_5_grad/Reshape" + input: "gradients/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_1_grad/stack" + op: "Pack" + input: "gradients/Slice_1_grad/Rank" + input: "gradients/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/sub" + op: "Sub" + input: "gradients/Slice_1_grad/Shape_1" + input: "gradients/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients/Slice_1_grad/sub_1" + input: "gradients/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients/Slice_1_grad/Reshape" + input: "gradients/Slice_1_grad/Reshape_1" + input: "gradients/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 + } + } +} +node { + name: "gradients/Slice_1_grad/Pad" + op: "Pad" + input: "gradients/Reshape_9_grad/Reshape" + input: "gradients/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_22" + op: "AddN" + input: "gradients/Slice_grad/Pad" + input: "gradients/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_22" + input: "gradients/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_37/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_37/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_37/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_37" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_37/stack" + input: "strided_slice_37/stack_1" + input: "strided_slice_37/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_22/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_22" + op: "Mul" + input: "strided_slice_37" + input: "mul_22/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_25/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_25/shape" + op: "Pack" + input: "Reshape_25/shape/0" + input: "mul_22" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_25" + op: "Reshape" + input: "gradients/Reshape_4_grad/Reshape" + input: "Reshape_25/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA" + op: "ProdForceSeA" + input: "Reshape_25" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 15 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA" + op: "ProdVirialSeA" + input: "Reshape_25" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 15 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_38/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_38/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_38/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_38" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_38/stack" + input: "strided_slice_38/stack_1" + input: "strided_slice_38/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_23/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_23" + op: "Mul" + input: "mul_23/x" + input: "strided_slice_38" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_26/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_26/shape" + op: "Pack" + input: "Reshape_26/shape/0" + input: "mul_23" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_26" + op: "Reshape" + input: "ProdForceSeA" + input: "Reshape_26/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_27/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_27" + op: "Reshape" + input: "ProdVirialSeA" + input: "Reshape_27/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_39/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_39/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_39/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_39" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_39/stack" + input: "strided_slice_39/stack_1" + input: "strided_slice_39/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_24/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_24" + op: "Mul" + input: "mul_24/x" + input: "strided_slice_39" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_28/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_28/shape" + op: "Pack" + input: "Reshape_28/shape/0" + input: "mul_24" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_28" + op: "Reshape" + input: "ProdVirialSeA:1" + input: "Reshape_28/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Shape" + op: "Shape" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients_1/grad_ys_0" + op: "Fill" + input: "gradients_1/Shape" + input: "gradients_1/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/zeros_like" + op: "ZerosLike" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/zeros_like_1" + op: "ZerosLike" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/split_grad/concat" + op: "ConcatV2" + input: "gradients_1/zeros_like" + input: "gradients_1/grad_ys_0" + input: "gradients_1/zeros_like_1" + input: "split/split_dim" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_24_grad/Shape" + op: "Shape" + input: "o_dipole" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_24_grad/Reshape" + op: "Reshape" + input: "gradients_1/split_grad/concat" + input: "gradients_1/Reshape_24_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/o_dipole_grad/Shape" + op: "Shape" + input: "Reshape_23" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/o_dipole_grad/Reshape" + op: "Reshape" + input: "gradients_1/Reshape_24_grad/Reshape" + input: "gradients_1/o_dipole_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_23_grad/Shape" + op: "Shape" + input: "concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_23_grad/Reshape" + op: "Reshape" + input: "gradients_1/o_dipole_grad/Reshape" + input: "gradients_1/Reshape_23_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_1/concat_2_grad/mod" + op: "FloorMod" + input: "concat_2/axis" + input: "gradients_1/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_2_grad/ShapeN" + op: "ShapeN" + input: "Reshape_18" + input: "Reshape_22" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/concat_2_grad/mod" + input: "gradients_1/concat_2_grad/ShapeN" + input: "gradients_1/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/concat_2_grad/Slice" + op: "Slice" + input: "gradients_1/Reshape_23_grad/Reshape" + input: "gradients_1/concat_2_grad/ConcatOffset" + input: "gradients_1/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_1/Reshape_23_grad/Reshape" + input: "gradients_1/concat_2_grad/ConcatOffset:1" + input: "gradients_1/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients_1/concat_2_grad/Slice" + input: "gradients_1/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_22_grad/Shape" + op: "Shape" + input: "MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients_1/concat_2_grad/Slice_1" + input: "gradients_1/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients_1/Reshape_18_grad/Reshape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_17" + input: "gradients_1/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/MatMul_grad/Shape" + input: "gradients_1/MatMul_grad/strided_slice/stack" + input: "gradients_1/MatMul_grad/strided_slice/stack_1" + input: "gradients_1/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/MatMul_grad/Shape_1" + input: "gradients_1/MatMul_grad/strided_slice_1/stack" + input: "gradients_1/MatMul_grad/strided_slice_1/stack_1" + input: "gradients_1/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/MatMul_grad/strided_slice" + input: "gradients_1/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/Sum" + op: "Sum" + input: "gradients_1/MatMul_grad/MatMul" + input: "gradients_1/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients_1/MatMul_grad/Sum" + input: "gradients_1/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients_1/MatMul_grad/MatMul_1" + input: "gradients_1/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/MatMul_grad/Sum_1" + input: "gradients_1/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_1_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients_1/Reshape_22_grad/Reshape" + input: "Reshape_20" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/MatMul_1_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_21" + input: "gradients_1/Reshape_22_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_1_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_1_grad/Shape_1" + op: "Shape" + input: "Reshape_20" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_1_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/MatMul_1_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/MatMul_1_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/MatMul_1_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/MatMul_1_grad/Shape" + input: "gradients_1/MatMul_1_grad/strided_slice/stack" + input: "gradients_1/MatMul_1_grad/strided_slice/stack_1" + input: "gradients_1/MatMul_1_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/MatMul_1_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/MatMul_1_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/MatMul_1_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/MatMul_1_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/MatMul_1_grad/Shape_1" + input: "gradients_1/MatMul_1_grad/strided_slice_1/stack" + input: "gradients_1/MatMul_1_grad/strided_slice_1/stack_1" + input: "gradients_1/MatMul_1_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/MatMul_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/MatMul_1_grad/strided_slice" + input: "gradients_1/MatMul_1_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_1_grad/Sum" + op: "Sum" + input: "gradients_1/MatMul_1_grad/MatMul" + input: "gradients_1/MatMul_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_1_grad/Reshape" + op: "Reshape" + input: "gradients_1/MatMul_1_grad/Sum" + input: "gradients_1/MatMul_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_1_grad/Sum_1" + op: "Sum" + input: "gradients_1/MatMul_1_grad/MatMul_1" + input: "gradients_1/MatMul_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/MatMul_1_grad/Sum_1" + input: "gradients_1/MatMul_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients_1/MatMul_grad/Reshape" + input: "gradients_1/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients_1/MatMul_grad/Reshape_1" + input: "gradients_1/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_21_grad/Shape" + op: "Shape" + input: "final_layer_type_1/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients_1/MatMul_1_grad/Reshape" + input: "gradients_1/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_20_grad/Shape" + op: "Shape" + input: "Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_20_grad/Reshape" + op: "Reshape" + input: "gradients_1/MatMul_1_grad/Reshape_1" + input: "gradients_1/Reshape_20_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/final_layer_type_0/add_grad/Shape" + input: "gradients_1/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/Reshape_17_grad/Reshape" + input: "gradients_1/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/final_layer_type_0/add_grad/Sum" + input: "gradients_1/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_1/Slice_3_grad/Rank" + input: "gradients_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_1/Slice_3_grad/Shape_1" + input: "gradients_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_1/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/Slice_3_grad/sub_1" + input: "gradients_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_1/Slice_3_grad/Reshape" + input: "gradients_1/Slice_3_grad/Reshape_1" + input: "gradients_1/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 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_1/Reshape_16_grad/Reshape" + input: "gradients_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_1/add_grad/Shape" + op: "Shape" + input: "final_layer_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_1/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/final_layer_type_1/add_grad/Shape" + input: "gradients_1/final_layer_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_1/Reshape_21_grad/Reshape" + input: "gradients_1/final_layer_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/final_layer_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/final_layer_type_1/add_grad/Sum" + input: "gradients_1/final_layer_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/Slice_5_grad/Shape" + op: "Shape" + input: "Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients_1/Slice_5_grad/Rank" + input: "gradients_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "Slice_5/begin" + input: "gradients_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients_1/Slice_5_grad/Shape_1" + input: "gradients_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_1/Slice_5_grad/sub" + input: "Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/Slice_5_grad/sub_1" + input: "gradients_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_1/Slice_5_grad/Reshape" + input: "gradients_1/Slice_5_grad/Reshape_1" + input: "gradients_1/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 + } + } +} +node { + name: "gradients_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_1/Reshape_20_grad/Reshape" + input: "gradients_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/final_layer_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/final_layer_type_1/add_grad/Reshape" + input: "final_layer_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/AddN" + op: "AddN" + input: "gradients_1/Slice_3_grad/Pad" + input: "gradients_1/Slice_5_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/Slice_3_grad/Pad" + } + } + } +} +node { + name: "gradients_1/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN" + input: "gradients_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_6_grad/Shape" + op: "Shape" + input: "add_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_6_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/add_6_grad/Shape" + input: "gradients_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_6_grad/Sum" + op: "Sum" + input: "gradients_1/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_1/add_6_grad/Sum" + input: "gradients_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_6_grad/Sum_1" + op: "Sum" + input: "gradients_1/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_1/add_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_6_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/add_6_grad/Sum_1" + input: "gradients_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_9_grad/Shape" + op: "Shape" + input: "add_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_9_grad/Shape_1" + op: "Shape" + input: "layer_2_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/add_9_grad/Shape" + input: "gradients_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_9_grad/Sum" + op: "Sum" + input: "gradients_1/final_layer_type_1/MatMul_grad/MatMul" + input: "gradients_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/add_9_grad/Sum" + input: "gradients_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_1/final_layer_type_1/MatMul_grad/MatMul" + input: "gradients_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/add_9_grad/Sum_1" + input: "gradients_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_2_type_0/mul_grad/Shape" + input: "gradients_1/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_1/add_6_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_1/layer_2_type_0/mul_grad/Mul" + input: "gradients_1/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_2_type_0/mul_grad/Sum" + input: "gradients_1/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_1/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_1/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_1/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_2_type_1/mul_grad/Shape" + input: "gradients_1/layer_2_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_1/add_9_grad/Reshape_1" + input: "layer_2_type_1/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_2_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_1/layer_2_type_1/mul_grad/Mul" + input: "gradients_1/layer_2_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_2_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_2_type_1/mul_grad/Sum" + input: "gradients_1/layer_2_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/concat_1_grad/mod" + input: "gradients_1/concat_1_grad/ShapeN" + input: "gradients_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients_1/Reshape_14_grad/Reshape" + input: "gradients_1/concat_1_grad/ConcatOffset" + input: "gradients_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_1/Reshape_14_grad/Reshape" + input: "gradients_1/concat_1_grad/ConcatOffset:1" + input: "gradients_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_2_type_0/mul_grad/Reshape" + input: "gradients_1/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_1/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_2_type_1/mul_grad/Reshape" + input: "gradients_1/layer_2_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/concat_1_grad/Slice" + input: "gradients_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_1/concat_1_grad/Slice_1" + input: "gradients_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients_1/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_2_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_1/Tanh" + input: "gradients_1/layer_2_type_1/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients_1/Reshape_8_grad/Reshape" + input: "gradients_1/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients_1/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_2_type_0/add_grad/Shape" + input: "gradients_1/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients_1/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_2_type_0/add_grad/Sum" + input: "gradients_1/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_1/add_grad/Shape" + op: "Shape" + input: "layer_2_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_1/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_2_type_1/add_grad/Shape" + input: "gradients_1/layer_2_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_1/layer_2_type_1/Tanh_grad/TanhGrad" + input: "gradients_1/layer_2_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_2_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_2_type_1/add_grad/Sum" + input: "gradients_1/layer_2_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_5_grad/Rank" + input: "gradients_1/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients_1/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_5_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_5_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_0/transpose_grad/transpose" + input: "gradients_1/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_5_grad/Rank" + input: "gradients_1/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients_1/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_5_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_5_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_1/transpose_grad/transpose" + input: "gradients_1/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/layer_2_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/layer_2_type_1/add_grad/Reshape" + input: "layer_2_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/AddN_1" + op: "AddN" + input: "gradients_1/add_6_grad/Reshape" + input: "gradients_1/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/add_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/add_5_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_5_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/add_5_grad/Shape" + input: "gradients_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_1" + input: "gradients_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/add_5_grad/Sum" + input: "gradients_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_5_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_1" + input: "gradients_1/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/add_5_grad/Sum_1" + input: "gradients_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_2" + op: "AddN" + input: "gradients_1/add_9_grad/Reshape" + input: "gradients_1/layer_2_type_1/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/add_8_grad/Shape" + op: "Shape" + input: "layer_0_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_8_grad/Shape_1" + op: "Shape" + input: "layer_1_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/add_8_grad/Shape" + input: "gradients_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_8_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_2" + input: "gradients_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/add_8_grad/Sum" + input: "gradients_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_8_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_2" + input: "gradients_1/add_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/add_8_grad/Sum_1" + input: "gradients_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_1_type_0/mul_grad/Shape" + input: "gradients_1/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_1/add_5_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_1/layer_1_type_0/mul_grad/Mul" + input: "gradients_1/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_1_type_0/mul_grad/Sum" + input: "gradients_1/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_1/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_1/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_1/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_1_type_1/mul_grad/Shape" + input: "gradients_1/layer_1_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_1/add_8_grad/Reshape_1" + input: "layer_1_type_1/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_1_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_1/layer_1_type_1/mul_grad/Mul" + input: "gradients_1/layer_1_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_1_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_1_type_1/mul_grad/Sum" + input: "gradients_1/layer_1_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_1_type_0/mul_grad/Reshape" + input: "gradients_1/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_1/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_1_type_1/mul_grad/Reshape" + input: "gradients_1/layer_1_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients_1/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_1_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_1/Tanh" + input: "gradients_1/layer_1_type_1/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_1_type_0/add_grad/Shape" + input: "gradients_1/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients_1/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_1_type_0/add_grad/Sum" + input: "gradients_1/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_1/add_grad/Shape" + op: "Shape" + input: "layer_1_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_1/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_1_type_1/add_grad/Shape" + input: "gradients_1/layer_1_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_1/layer_1_type_1/Tanh_grad/TanhGrad" + input: "gradients_1/layer_1_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_1_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_1_type_1/add_grad/Sum" + input: "gradients_1/layer_1_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/layer_1_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/layer_1_type_1/add_grad/Reshape" + input: "layer_1_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/AddN_3" + op: "AddN" + input: "gradients_1/add_5_grad/Reshape" + input: "gradients_1/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_3" + input: "gradients_1/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_4" + op: "AddN" + input: "gradients_1/add_8_grad/Reshape" + input: "gradients_1/layer_1_type_1/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/add_8_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/layer_0_type_1/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_4" + input: "gradients_1/layer_0_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients_1/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_0_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_1/Tanh" + input: "gradients_1/layer_0_type_1/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_0_type_0/add_grad/Shape" + input: "gradients_1/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients_1/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_0_type_0/add_grad/Sum" + input: "gradients_1/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_1/add_grad/Shape" + op: "Shape" + input: "layer_0_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_1/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_0_type_1/add_grad/Shape" + input: "gradients_1/layer_0_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_1/layer_0_type_1/Tanh_grad/TanhGrad" + input: "gradients_1/layer_0_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_0_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_0_type_1/add_grad/Sum" + input: "gradients_1/layer_0_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/layer_0_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/layer_0_type_1/add_grad/Reshape" + input: "layer_0_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients_1/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_19_grad/Shape" + op: "Shape" + input: "Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_19_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_0_type_1/MatMul_grad/MatMul" + input: "gradients_1/Reshape_19_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_1/Slice_2_grad/Rank" + input: "gradients_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_1/Slice_2_grad/Shape_1" + input: "gradients_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_1/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/Slice_2_grad/sub_1" + input: "gradients_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_1/Slice_2_grad/Reshape" + input: "gradients_1/Slice_2_grad/Reshape_1" + input: "gradients_1/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 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_1/Reshape_15_grad/Reshape" + input: "gradients_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/Slice_4_grad/Shape" + op: "Shape" + input: "Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients_1/Slice_4_grad/Rank" + input: "gradients_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "Slice_4/begin" + input: "gradients_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients_1/Slice_4_grad/Shape_1" + input: "gradients_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_1/Slice_4_grad/sub" + input: "Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/Slice_4_grad/sub_1" + input: "gradients_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_1/Slice_4_grad/Reshape" + input: "gradients_1/Slice_4_grad/Reshape_1" + input: "gradients_1/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 + } + } +} +node { + name: "gradients_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_1/Reshape_19_grad/Reshape" + input: "gradients_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_5" + op: "AddN" + input: "gradients_1/Slice_2_grad/Pad" + input: "gradients_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/Slice_2_grad/Pad" + } + } + } +} +node { + name: "gradients_1/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_5" + input: "gradients_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/concat_grad/mod" + input: "gradients_1/concat_grad/ShapeN" + input: "gradients_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/concat_grad/Slice" + op: "Slice" + input: "gradients_1/Reshape_13_grad/Reshape" + input: "gradients_1/concat_grad/ConcatOffset" + input: "gradients_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients_1/Reshape_13_grad/Reshape" + input: "gradients_1/concat_grad/ConcatOffset:1" + input: "gradients_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/concat_grad/Slice" + input: "gradients_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_1/concat_grad/Slice_1" + input: "gradients_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_1/Reshape_7_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_1/Reshape_11_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients_1/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients_1/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_8_grad/Shape" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients_1/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_8_grad/Sum" + input: "gradients_1/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients_1/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients_1/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_8_grad/Shape" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients_1/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_8_grad/Sum" + input: "gradients_1/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_4_grad/Rank" + input: "gradients_1/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients_1/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_4_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_4_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients_1/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_4_grad/Rank" + input: "gradients_1/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients_1/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_4_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_4_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients_1/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_6" + op: "AddN" + input: "gradients_1/filter_type_0/Slice_5_grad/Pad" + input: "gradients_1/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/mul_grad/Shape" + input: "gradients_1/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_1/AddN_6" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/mul_grad/Mul" + input: "gradients_1/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/mul_grad/Sum" + input: "gradients_1/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_7" + op: "AddN" + input: "gradients_1/filter_type_1/Slice_5_grad/Pad" + input: "gradients_1/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/mul_grad/Shape" + input: "gradients_1/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_1/AddN_7" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/mul_grad/Mul" + input: "gradients_1/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/mul_grad/Sum" + input: "gradients_1/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_10_grad/Shape" + input: "gradients_1/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/mul_grad/Reshape" + input: "gradients_1/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_10_grad/Sum" + input: "gradients_1/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/mul_grad/Reshape" + input: "gradients_1/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_10_grad/Sum_1" + input: "gradients_1/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_10_grad/Shape" + input: "gradients_1/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/mul_grad/Reshape" + input: "gradients_1/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_10_grad/Sum" + input: "gradients_1/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/mul_grad/Reshape" + input: "gradients_1/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_10_grad/Sum_1" + input: "gradients_1/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients_1/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients_1/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_3_grad/Shape" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients_1/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_3_grad/Sum" + input: "gradients_1/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients_1/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients_1/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_7_grad/Shape" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients_1/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_7_grad/Sum" + input: "gradients_1/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients_1/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients_1/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_3_grad/Shape" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients_1/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_3_grad/Sum" + input: "gradients_1/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients_1/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients_1/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_7_grad/Shape" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients_1/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_7_grad/Sum" + input: "gradients_1/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/add_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_4_grad/Shape" + input: "gradients_1/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_1/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_4_grad/Sum" + input: "gradients_1/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_1/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_4_grad/Sum_1" + input: "gradients_1/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_9_grad/Shape" + input: "gradients_1/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_9_grad/Sum" + input: "gradients_1/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_9_grad/Sum_1" + input: "gradients_1/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/add_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_4_grad/Shape" + input: "gradients_1/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_1/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_4_grad/Sum" + input: "gradients_1/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_1/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_4_grad/Sum_1" + input: "gradients_1/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_9_grad/Shape" + input: "gradients_1/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_9_grad/Sum" + input: "gradients_1/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_9_grad/Sum_1" + input: "gradients_1/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_4_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_9_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_4_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_9_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients_1/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients_1/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients_1/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients_1/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_3_grad/Shape" + input: "gradients_1/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_3_grad/Sum" + input: "gradients_1/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_8_grad/Shape" + input: "gradients_1/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_8_grad/Sum" + input: "gradients_1/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_3_grad/Shape" + input: "gradients_1/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_3_grad/Sum" + input: "gradients_1/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_8_grad/Shape" + input: "gradients_1/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_8_grad/Sum" + input: "gradients_1/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/AddN_8" + op: "AddN" + input: "gradients_1/filter_type_0/add_4_grad/Reshape" + input: "gradients_1/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_2_grad/Shape" + input: "gradients_1/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_8" + input: "gradients_1/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_2_grad/Sum" + input: "gradients_1/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_8" + input: "gradients_1/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_2_grad/Sum_1" + input: "gradients_1/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_9" + op: "AddN" + input: "gradients_1/filter_type_0/add_9_grad/Reshape" + input: "gradients_1/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_7_grad/Shape" + input: "gradients_1/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_9" + input: "gradients_1/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_7_grad/Sum" + input: "gradients_1/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_9" + input: "gradients_1/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_7_grad/Sum_1" + input: "gradients_1/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_10" + op: "AddN" + input: "gradients_1/filter_type_1/add_4_grad/Reshape" + input: "gradients_1/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_2_grad/Shape" + input: "gradients_1/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_10" + input: "gradients_1/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_2_grad/Sum" + input: "gradients_1/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_10" + input: "gradients_1/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_2_grad/Sum_1" + input: "gradients_1/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_11" + op: "AddN" + input: "gradients_1/filter_type_1/add_9_grad/Reshape" + input: "gradients_1/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_7_grad/Shape" + input: "gradients_1/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_11" + input: "gradients_1/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_7_grad/Sum" + input: "gradients_1/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_11" + input: "gradients_1/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_7_grad/Sum_1" + input: "gradients_1/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_2_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_7_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_2_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_7_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients_1/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients_1/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients_1/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients_1/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_1_grad/Shape" + input: "gradients_1/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_1_grad/Sum" + input: "gradients_1/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_6_grad/Shape" + input: "gradients_1/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_6_grad/Sum" + input: "gradients_1/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_1_grad/Shape" + input: "gradients_1/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_1_grad/Sum" + input: "gradients_1/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_6_grad/Shape" + input: "gradients_1/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_6_grad/Sum" + input: "gradients_1/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/AddN_12" + op: "AddN" + input: "gradients_1/filter_type_0/add_2_grad/Reshape" + input: "gradients_1/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/add_2_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_12" + input: "gradients_1/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_13" + op: "AddN" + input: "gradients_1/filter_type_0/add_7_grad/Reshape" + input: "gradients_1/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/add_7_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_13" + input: "gradients_1/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_14" + op: "AddN" + input: "gradients_1/filter_type_1/add_2_grad/Reshape" + input: "gradients_1/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/add_2_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_14" + input: "gradients_1/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_15" + op: "AddN" + input: "gradients_1/filter_type_1/add_7_grad/Reshape" + input: "gradients_1/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/add_7_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_15" + input: "gradients_1/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients_1/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients_1/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients_1/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients_1/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_grad/Shape" + input: "gradients_1/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_grad/Sum" + input: "gradients_1/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_5_grad/Shape" + input: "gradients_1/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_5_grad/Sum" + input: "gradients_1/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_grad/Shape" + input: "gradients_1/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_grad/Sum" + input: "gradients_1/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_5_grad/Shape" + input: "gradients_1/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_5_grad/Sum" + input: "gradients_1/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_grad/MatMul" + input: "gradients_1/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients_1/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_grad/MatMul" + input: "gradients_1/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients_1/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_1_grad/Rank" + input: "gradients_1/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients_1/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_1_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_1_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_3_grad/Rank" + input: "gradients_1/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients_1/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_3_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_3_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_1_grad/Rank" + input: "gradients_1/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients_1/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_1_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_1_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_3_grad/Rank" + input: "gradients_1/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients_1/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_3_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_3_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_1_grad/Pad" + input: "gradients_1/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_3_grad/Pad" + input: "gradients_1/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_1_grad/Pad" + input: "gradients_1/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_3_grad/Pad" + input: "gradients_1/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_16" + op: "AddN" + input: "gradients_1/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_grad/Rank" + input: "gradients_1/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients_1/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_grad/Reshape_1" + input: "gradients_1/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients_1/AddN_16" + input: "gradients_1/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_17" + op: "AddN" + input: "gradients_1/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_2_grad/Rank" + input: "gradients_1/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients_1/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_2_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_2_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_1/AddN_17" + input: "gradients_1/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_18" + op: "AddN" + input: "gradients_1/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_grad/Rank" + input: "gradients_1/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients_1/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_grad/Reshape_1" + input: "gradients_1/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_1/AddN_18" + input: "gradients_1/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_19" + op: "AddN" + input: "gradients_1/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_2_grad/Rank" + input: "gradients_1/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients_1/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_2_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_2_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_1/AddN_19" + input: "gradients_1/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_20" + op: "AddN" + input: "gradients_1/filter_type_0/Slice_grad/Pad" + input: "gradients_1/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_1/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_20" + input: "gradients_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_21" + op: "AddN" + input: "gradients_1/filter_type_1/Slice_grad/Pad" + input: "gradients_1/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_1/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_21" + input: "gradients_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_grad/stack" + op: "Pack" + input: "gradients_1/Slice_grad/Rank" + input: "gradients_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/sub" + op: "Sub" + input: "gradients_1/Slice_grad/Shape_1" + input: "gradients_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_1/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/Slice_grad/sub_1" + input: "gradients_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_1/Slice_grad/Reshape" + input: "gradients_1/Slice_grad/Reshape_1" + input: "gradients_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_1/Reshape_5_grad/Reshape" + input: "gradients_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_1/Slice_1_grad/Rank" + input: "gradients_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_1/Slice_1_grad/Shape_1" + input: "gradients_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_1/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/Slice_1_grad/sub_1" + input: "gradients_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_1/Slice_1_grad/Reshape" + input: "gradients_1/Slice_1_grad/Reshape_1" + input: "gradients_1/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 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_1/Reshape_9_grad/Reshape" + input: "gradients_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_22" + op: "AddN" + input: "gradients_1/Slice_grad/Pad" + input: "gradients_1/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_1/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_22" + input: "gradients_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_40/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_40/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_40/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_40" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_40/stack" + input: "strided_slice_40/stack_1" + input: "strided_slice_40/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_25/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_25" + op: "Mul" + input: "strided_slice_40" + input: "mul_25/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_29/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_29/shape" + op: "Pack" + input: "Reshape_29/shape/0" + input: "mul_25" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_29" + op: "Reshape" + input: "gradients_1/Reshape_4_grad/Reshape" + input: "Reshape_29/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA_1" + op: "ProdForceSeA" + input: "Reshape_29" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 15 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA_1" + op: "ProdVirialSeA" + input: "Reshape_29" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 15 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_41/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_41/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_41/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_41" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_41/stack" + input: "strided_slice_41/stack_1" + input: "strided_slice_41/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_26/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_26" + op: "Mul" + input: "mul_26/x" + input: "strided_slice_41" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_30/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_30/shape" + op: "Pack" + input: "Reshape_30/shape/0" + input: "mul_26" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_30" + op: "Reshape" + input: "ProdForceSeA_1" + input: "Reshape_30/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_31/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_31" + op: "Reshape" + input: "ProdVirialSeA_1" + input: "Reshape_31/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_42/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_42/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_42/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_42" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_42/stack" + input: "strided_slice_42/stack_1" + input: "strided_slice_42/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_27/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_27" + op: "Mul" + input: "mul_27/x" + input: "strided_slice_42" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_32/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_32/shape" + op: "Pack" + input: "Reshape_32/shape/0" + input: "mul_27" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_32" + op: "Reshape" + input: "ProdVirialSeA_1:1" + input: "Reshape_32/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Shape" + op: "Shape" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients_2/grad_ys_0" + op: "Fill" + input: "gradients_2/Shape" + input: "gradients_2/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/zeros_like" + op: "ZerosLike" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/zeros_like_1" + op: "ZerosLike" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/split_grad/concat" + op: "ConcatV2" + input: "gradients_2/zeros_like" + input: "gradients_2/zeros_like_1" + input: "gradients_2/grad_ys_0" + input: "split/split_dim" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_24_grad/Shape" + op: "Shape" + input: "o_dipole" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_24_grad/Reshape" + op: "Reshape" + input: "gradients_2/split_grad/concat" + input: "gradients_2/Reshape_24_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/o_dipole_grad/Shape" + op: "Shape" + input: "Reshape_23" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/o_dipole_grad/Reshape" + op: "Reshape" + input: "gradients_2/Reshape_24_grad/Reshape" + input: "gradients_2/o_dipole_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_23_grad/Shape" + op: "Shape" + input: "concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_23_grad/Reshape" + op: "Reshape" + input: "gradients_2/o_dipole_grad/Reshape" + input: "gradients_2/Reshape_23_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_2/concat_2_grad/mod" + op: "FloorMod" + input: "concat_2/axis" + input: "gradients_2/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_2_grad/ShapeN" + op: "ShapeN" + input: "Reshape_18" + input: "Reshape_22" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/concat_2_grad/mod" + input: "gradients_2/concat_2_grad/ShapeN" + input: "gradients_2/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/concat_2_grad/Slice" + op: "Slice" + input: "gradients_2/Reshape_23_grad/Reshape" + input: "gradients_2/concat_2_grad/ConcatOffset" + input: "gradients_2/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_2/Reshape_23_grad/Reshape" + input: "gradients_2/concat_2_grad/ConcatOffset:1" + input: "gradients_2/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients_2/concat_2_grad/Slice" + input: "gradients_2/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_22_grad/Shape" + op: "Shape" + input: "MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients_2/concat_2_grad/Slice_1" + input: "gradients_2/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients_2/Reshape_18_grad/Reshape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_17" + input: "gradients_2/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/MatMul_grad/Shape" + input: "gradients_2/MatMul_grad/strided_slice/stack" + input: "gradients_2/MatMul_grad/strided_slice/stack_1" + input: "gradients_2/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/MatMul_grad/Shape_1" + input: "gradients_2/MatMul_grad/strided_slice_1/stack" + input: "gradients_2/MatMul_grad/strided_slice_1/stack_1" + input: "gradients_2/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/MatMul_grad/strided_slice" + input: "gradients_2/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/Sum" + op: "Sum" + input: "gradients_2/MatMul_grad/MatMul" + input: "gradients_2/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients_2/MatMul_grad/Sum" + input: "gradients_2/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients_2/MatMul_grad/MatMul_1" + input: "gradients_2/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/MatMul_grad/Sum_1" + input: "gradients_2/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_1_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients_2/Reshape_22_grad/Reshape" + input: "Reshape_20" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/MatMul_1_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_21" + input: "gradients_2/Reshape_22_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_1_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_1_grad/Shape_1" + op: "Shape" + input: "Reshape_20" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_1_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/MatMul_1_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/MatMul_1_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/MatMul_1_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/MatMul_1_grad/Shape" + input: "gradients_2/MatMul_1_grad/strided_slice/stack" + input: "gradients_2/MatMul_1_grad/strided_slice/stack_1" + input: "gradients_2/MatMul_1_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/MatMul_1_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/MatMul_1_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/MatMul_1_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/MatMul_1_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/MatMul_1_grad/Shape_1" + input: "gradients_2/MatMul_1_grad/strided_slice_1/stack" + input: "gradients_2/MatMul_1_grad/strided_slice_1/stack_1" + input: "gradients_2/MatMul_1_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/MatMul_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/MatMul_1_grad/strided_slice" + input: "gradients_2/MatMul_1_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_1_grad/Sum" + op: "Sum" + input: "gradients_2/MatMul_1_grad/MatMul" + input: "gradients_2/MatMul_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_1_grad/Reshape" + op: "Reshape" + input: "gradients_2/MatMul_1_grad/Sum" + input: "gradients_2/MatMul_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_1_grad/Sum_1" + op: "Sum" + input: "gradients_2/MatMul_1_grad/MatMul_1" + input: "gradients_2/MatMul_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/MatMul_1_grad/Sum_1" + input: "gradients_2/MatMul_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients_2/MatMul_grad/Reshape" + input: "gradients_2/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients_2/MatMul_grad/Reshape_1" + input: "gradients_2/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_21_grad/Shape" + op: "Shape" + input: "final_layer_type_1/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients_2/MatMul_1_grad/Reshape" + input: "gradients_2/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_20_grad/Shape" + op: "Shape" + input: "Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_20_grad/Reshape" + op: "Reshape" + input: "gradients_2/MatMul_1_grad/Reshape_1" + input: "gradients_2/Reshape_20_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/final_layer_type_0/add_grad/Shape" + input: "gradients_2/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/Reshape_17_grad/Reshape" + input: "gradients_2/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/final_layer_type_0/add_grad/Sum" + input: "gradients_2/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_3_grad/stack" + op: "Pack" + input: "gradients_2/Slice_3_grad/Rank" + input: "gradients_2/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients_2/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/sub" + op: "Sub" + input: "gradients_2/Slice_3_grad/Shape_1" + input: "gradients_2/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_2/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/Slice_3_grad/sub_1" + input: "gradients_2/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_2/Slice_3_grad/Reshape" + input: "gradients_2/Slice_3_grad/Reshape_1" + input: "gradients_2/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 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_2/Reshape_16_grad/Reshape" + input: "gradients_2/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_1/add_grad/Shape" + op: "Shape" + input: "final_layer_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_1/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/final_layer_type_1/add_grad/Shape" + input: "gradients_2/final_layer_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_2/Reshape_21_grad/Reshape" + input: "gradients_2/final_layer_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/final_layer_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/final_layer_type_1/add_grad/Sum" + input: "gradients_2/final_layer_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/Slice_5_grad/Shape" + op: "Shape" + input: "Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_5_grad/stack" + op: "Pack" + input: "gradients_2/Slice_5_grad/Rank" + input: "gradients_2/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/Slice_5_grad/Reshape" + op: "Reshape" + input: "Slice_5/begin" + input: "gradients_2/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_5_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_5_grad/sub" + op: "Sub" + input: "gradients_2/Slice_5_grad/Shape_1" + input: "gradients_2/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_2/Slice_5_grad/sub" + input: "Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/Slice_5_grad/sub_1" + input: "gradients_2/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_2/Slice_5_grad/Reshape" + input: "gradients_2/Slice_5_grad/Reshape_1" + input: "gradients_2/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 + } + } +} +node { + name: "gradients_2/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_2/Reshape_20_grad/Reshape" + input: "gradients_2/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/final_layer_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/final_layer_type_1/add_grad/Reshape" + input: "final_layer_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/AddN" + op: "AddN" + input: "gradients_2/Slice_3_grad/Pad" + input: "gradients_2/Slice_5_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/Slice_3_grad/Pad" + } + } + } +} +node { + name: "gradients_2/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN" + input: "gradients_2/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_6_grad/Shape" + op: "Shape" + input: "add_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_6_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/add_6_grad/Shape" + input: "gradients_2/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_6_grad/Sum" + op: "Sum" + input: "gradients_2/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_2/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_2/add_6_grad/Sum" + input: "gradients_2/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_6_grad/Sum_1" + op: "Sum" + input: "gradients_2/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_2/add_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_6_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/add_6_grad/Sum_1" + input: "gradients_2/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_9_grad/Shape" + op: "Shape" + input: "add_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_9_grad/Shape_1" + op: "Shape" + input: "layer_2_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/add_9_grad/Shape" + input: "gradients_2/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_9_grad/Sum" + op: "Sum" + input: "gradients_2/final_layer_type_1/MatMul_grad/MatMul" + input: "gradients_2/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/add_9_grad/Sum" + input: "gradients_2/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_2/final_layer_type_1/MatMul_grad/MatMul" + input: "gradients_2/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/add_9_grad/Sum_1" + input: "gradients_2/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_2_type_0/mul_grad/Shape" + input: "gradients_2/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_2/add_6_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_2/layer_2_type_0/mul_grad/Mul" + input: "gradients_2/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_2_type_0/mul_grad/Sum" + input: "gradients_2/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_1/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_1/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_1/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_2_type_1/mul_grad/Shape" + input: "gradients_2/layer_2_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_2/add_9_grad/Reshape_1" + input: "layer_2_type_1/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_2_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_2/layer_2_type_1/mul_grad/Mul" + input: "gradients_2/layer_2_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_2_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_2_type_1/mul_grad/Sum" + input: "gradients_2/layer_2_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients_2/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/concat_1_grad/mod" + input: "gradients_2/concat_1_grad/ShapeN" + input: "gradients_2/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/concat_1_grad/Slice" + op: "Slice" + input: "gradients_2/Reshape_14_grad/Reshape" + input: "gradients_2/concat_1_grad/ConcatOffset" + input: "gradients_2/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_2/Reshape_14_grad/Reshape" + input: "gradients_2/concat_1_grad/ConcatOffset:1" + input: "gradients_2/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_2_type_0/mul_grad/Reshape" + input: "gradients_2/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_1/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_2_type_1/mul_grad/Reshape" + input: "gradients_2/layer_2_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/concat_1_grad/Slice" + input: "gradients_2/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_2/concat_1_grad/Slice_1" + input: "gradients_2/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients_2/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_2_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_1/Tanh" + input: "gradients_2/layer_2_type_1/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients_2/Reshape_8_grad/Reshape" + input: "gradients_2/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients_2/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_2_type_0/add_grad/Shape" + input: "gradients_2/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients_2/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_2_type_0/add_grad/Sum" + input: "gradients_2/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_1/add_grad/Shape" + op: "Shape" + input: "layer_2_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_1/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_2_type_1/add_grad/Shape" + input: "gradients_2/layer_2_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_2/layer_2_type_1/Tanh_grad/TanhGrad" + input: "gradients_2/layer_2_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_2_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_2_type_1/add_grad/Sum" + input: "gradients_2/layer_2_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_5_grad/Rank" + input: "gradients_2/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients_2/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_5_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_5_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_0/transpose_grad/transpose" + input: "gradients_2/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_5_grad/Rank" + input: "gradients_2/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients_2/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_5_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_5_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_1/transpose_grad/transpose" + input: "gradients_2/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/layer_2_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/layer_2_type_1/add_grad/Reshape" + input: "layer_2_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/AddN_1" + op: "AddN" + input: "gradients_2/add_6_grad/Reshape" + input: "gradients_2/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/add_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/add_5_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_5_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/add_5_grad/Shape" + input: "gradients_2/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_5_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_1" + input: "gradients_2/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/add_5_grad/Sum" + input: "gradients_2/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_5_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_1" + input: "gradients_2/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/add_5_grad/Sum_1" + input: "gradients_2/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_2" + op: "AddN" + input: "gradients_2/add_9_grad/Reshape" + input: "gradients_2/layer_2_type_1/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/add_8_grad/Shape" + op: "Shape" + input: "layer_0_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_8_grad/Shape_1" + op: "Shape" + input: "layer_1_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/add_8_grad/Shape" + input: "gradients_2/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_8_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_2" + input: "gradients_2/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/add_8_grad/Sum" + input: "gradients_2/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_8_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_2" + input: "gradients_2/add_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/add_8_grad/Sum_1" + input: "gradients_2/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_1_type_0/mul_grad/Shape" + input: "gradients_2/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_2/add_5_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_2/layer_1_type_0/mul_grad/Mul" + input: "gradients_2/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_1_type_0/mul_grad/Sum" + input: "gradients_2/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_1/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_1/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_1/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_1_type_1/mul_grad/Shape" + input: "gradients_2/layer_1_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_2/add_8_grad/Reshape_1" + input: "layer_1_type_1/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_1_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_2/layer_1_type_1/mul_grad/Mul" + input: "gradients_2/layer_1_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_1_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_1_type_1/mul_grad/Sum" + input: "gradients_2/layer_1_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_1_type_0/mul_grad/Reshape" + input: "gradients_2/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_1/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_1_type_1/mul_grad/Reshape" + input: "gradients_2/layer_1_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients_2/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_1_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_1/Tanh" + input: "gradients_2/layer_1_type_1/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_1_type_0/add_grad/Shape" + input: "gradients_2/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients_2/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_1_type_0/add_grad/Sum" + input: "gradients_2/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_1/add_grad/Shape" + op: "Shape" + input: "layer_1_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_1/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_1_type_1/add_grad/Shape" + input: "gradients_2/layer_1_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_2/layer_1_type_1/Tanh_grad/TanhGrad" + input: "gradients_2/layer_1_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_1_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_1_type_1/add_grad/Sum" + input: "gradients_2/layer_1_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/layer_1_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/layer_1_type_1/add_grad/Reshape" + input: "layer_1_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/AddN_3" + op: "AddN" + input: "gradients_2/add_5_grad/Reshape" + input: "gradients_2/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_3" + input: "gradients_2/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_4" + op: "AddN" + input: "gradients_2/add_8_grad/Reshape" + input: "gradients_2/layer_1_type_1/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/add_8_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/layer_0_type_1/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_4" + input: "gradients_2/layer_0_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients_2/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_0_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_1/Tanh" + input: "gradients_2/layer_0_type_1/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_0_type_0/add_grad/Shape" + input: "gradients_2/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients_2/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_0_type_0/add_grad/Sum" + input: "gradients_2/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_1/add_grad/Shape" + op: "Shape" + input: "layer_0_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_1/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_1/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_0_type_1/add_grad/Shape" + input: "gradients_2/layer_0_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_2/layer_0_type_1/Tanh_grad/TanhGrad" + input: "gradients_2/layer_0_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_0_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_0_type_1/add_grad/Sum" + input: "gradients_2/layer_0_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/layer_0_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/layer_0_type_1/add_grad/Reshape" + input: "layer_0_type_1/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients_2/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_19_grad/Shape" + op: "Shape" + input: "Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_19_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_0_type_1/MatMul_grad/MatMul" + input: "gradients_2/Reshape_19_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_2_grad/stack" + op: "Pack" + input: "gradients_2/Slice_2_grad/Rank" + input: "gradients_2/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients_2/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/sub" + op: "Sub" + input: "gradients_2/Slice_2_grad/Shape_1" + input: "gradients_2/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_2/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/Slice_2_grad/sub_1" + input: "gradients_2/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_2/Slice_2_grad/Reshape" + input: "gradients_2/Slice_2_grad/Reshape_1" + input: "gradients_2/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 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_2/Reshape_15_grad/Reshape" + input: "gradients_2/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/Slice_4_grad/Shape" + op: "Shape" + input: "Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_4_grad/stack" + op: "Pack" + input: "gradients_2/Slice_4_grad/Rank" + input: "gradients_2/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/Slice_4_grad/Reshape" + op: "Reshape" + input: "Slice_4/begin" + input: "gradients_2/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_4_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_4_grad/sub" + op: "Sub" + input: "gradients_2/Slice_4_grad/Shape_1" + input: "gradients_2/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_2/Slice_4_grad/sub" + input: "Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/Slice_4_grad/sub_1" + input: "gradients_2/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_2/Slice_4_grad/Reshape" + input: "gradients_2/Slice_4_grad/Reshape_1" + input: "gradients_2/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 + } + } +} +node { + name: "gradients_2/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_2/Reshape_19_grad/Reshape" + input: "gradients_2/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_5" + op: "AddN" + input: "gradients_2/Slice_2_grad/Pad" + input: "gradients_2/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/Slice_2_grad/Pad" + } + } + } +} +node { + name: "gradients_2/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_5" + input: "gradients_2/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients_2/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/concat_grad/mod" + input: "gradients_2/concat_grad/ShapeN" + input: "gradients_2/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/concat_grad/Slice" + op: "Slice" + input: "gradients_2/Reshape_13_grad/Reshape" + input: "gradients_2/concat_grad/ConcatOffset" + input: "gradients_2/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/concat_grad/Slice_1" + op: "Slice" + input: "gradients_2/Reshape_13_grad/Reshape" + input: "gradients_2/concat_grad/ConcatOffset:1" + input: "gradients_2/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/concat_grad/Slice" + input: "gradients_2/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_2/concat_grad/Slice_1" + input: "gradients_2/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_2/Reshape_7_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_2/Reshape_11_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients_2/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients_2/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_8_grad/Shape" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients_2/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_8_grad/Sum" + input: "gradients_2/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients_2/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients_2/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_8_grad/Shape" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients_2/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_8_grad/Sum" + input: "gradients_2/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_4_grad/Rank" + input: "gradients_2/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients_2/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_4_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_4_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients_2/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_4_grad/Rank" + input: "gradients_2/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients_2/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_4_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_4_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients_2/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_6" + op: "AddN" + input: "gradients_2/filter_type_0/Slice_5_grad/Pad" + input: "gradients_2/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/mul_grad/Shape" + input: "gradients_2/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_2/AddN_6" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/mul_grad/Mul" + input: "gradients_2/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/mul_grad/Sum" + input: "gradients_2/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_7" + op: "AddN" + input: "gradients_2/filter_type_1/Slice_5_grad/Pad" + input: "gradients_2/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/mul_grad/Shape" + input: "gradients_2/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_2/AddN_7" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/mul_grad/Mul" + input: "gradients_2/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/mul_grad/Sum" + input: "gradients_2/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_10_grad/Shape" + input: "gradients_2/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/mul_grad/Reshape" + input: "gradients_2/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_10_grad/Sum" + input: "gradients_2/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/mul_grad/Reshape" + input: "gradients_2/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_10_grad/Sum_1" + input: "gradients_2/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_10_grad/Shape" + input: "gradients_2/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/mul_grad/Reshape" + input: "gradients_2/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_10_grad/Sum" + input: "gradients_2/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/mul_grad/Reshape" + input: "gradients_2/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_10_grad/Sum_1" + input: "gradients_2/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients_2/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients_2/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_3_grad/Shape" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients_2/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_3_grad/Sum" + input: "gradients_2/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients_2/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients_2/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_7_grad/Shape" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients_2/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_7_grad/Sum" + input: "gradients_2/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients_2/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients_2/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_3_grad/Shape" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients_2/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_3_grad/Sum" + input: "gradients_2/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients_2/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients_2/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_7_grad/Shape" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients_2/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_7_grad/Sum" + input: "gradients_2/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/add_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_4_grad/Shape" + input: "gradients_2/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_2/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_4_grad/Sum" + input: "gradients_2/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_2/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_4_grad/Sum_1" + input: "gradients_2/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_9_grad/Shape" + input: "gradients_2/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_9_grad/Sum" + input: "gradients_2/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_9_grad/Sum_1" + input: "gradients_2/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/add_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_4_grad/Shape" + input: "gradients_2/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_2/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_4_grad/Sum" + input: "gradients_2/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_2/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_4_grad/Sum_1" + input: "gradients_2/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_9_grad/Shape" + input: "gradients_2/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_9_grad/Sum" + input: "gradients_2/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_9_grad/Sum_1" + input: "gradients_2/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_4_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_9_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_4_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_9_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients_2/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients_2/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients_2/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients_2/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_3_grad/Shape" + input: "gradients_2/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_3_grad/Sum" + input: "gradients_2/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_8_grad/Shape" + input: "gradients_2/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_8_grad/Sum" + input: "gradients_2/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_3_grad/Shape" + input: "gradients_2/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_3_grad/Sum" + input: "gradients_2/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_8_grad/Shape" + input: "gradients_2/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_8_grad/Sum" + input: "gradients_2/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/AddN_8" + op: "AddN" + input: "gradients_2/filter_type_0/add_4_grad/Reshape" + input: "gradients_2/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_2_grad/Shape" + input: "gradients_2/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_8" + input: "gradients_2/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_2_grad/Sum" + input: "gradients_2/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_8" + input: "gradients_2/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_2_grad/Sum_1" + input: "gradients_2/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_9" + op: "AddN" + input: "gradients_2/filter_type_0/add_9_grad/Reshape" + input: "gradients_2/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_7_grad/Shape" + input: "gradients_2/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_9" + input: "gradients_2/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_7_grad/Sum" + input: "gradients_2/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_9" + input: "gradients_2/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_7_grad/Sum_1" + input: "gradients_2/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_10" + op: "AddN" + input: "gradients_2/filter_type_1/add_4_grad/Reshape" + input: "gradients_2/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_2_grad/Shape" + input: "gradients_2/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_10" + input: "gradients_2/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_2_grad/Sum" + input: "gradients_2/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_10" + input: "gradients_2/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_2_grad/Sum_1" + input: "gradients_2/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_11" + op: "AddN" + input: "gradients_2/filter_type_1/add_9_grad/Reshape" + input: "gradients_2/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_7_grad/Shape" + input: "gradients_2/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_11" + input: "gradients_2/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_7_grad/Sum" + input: "gradients_2/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_11" + input: "gradients_2/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_7_grad/Sum_1" + input: "gradients_2/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_2_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_7_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_2_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_7_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients_2/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients_2/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients_2/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients_2/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_1_grad/Shape" + input: "gradients_2/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_1_grad/Sum" + input: "gradients_2/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_6_grad/Shape" + input: "gradients_2/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_6_grad/Sum" + input: "gradients_2/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_1_grad/Shape" + input: "gradients_2/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_1_grad/Sum" + input: "gradients_2/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_6_grad/Shape" + input: "gradients_2/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_6_grad/Sum" + input: "gradients_2/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/AddN_12" + op: "AddN" + input: "gradients_2/filter_type_0/add_2_grad/Reshape" + input: "gradients_2/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/add_2_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_12" + input: "gradients_2/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_13" + op: "AddN" + input: "gradients_2/filter_type_0/add_7_grad/Reshape" + input: "gradients_2/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/add_7_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_13" + input: "gradients_2/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_14" + op: "AddN" + input: "gradients_2/filter_type_1/add_2_grad/Reshape" + input: "gradients_2/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/add_2_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_14" + input: "gradients_2/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_15" + op: "AddN" + input: "gradients_2/filter_type_1/add_7_grad/Reshape" + input: "gradients_2/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/add_7_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_15" + input: "gradients_2/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients_2/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients_2/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients_2/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients_2/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_grad/Shape" + input: "gradients_2/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_grad/Sum" + input: "gradients_2/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_5_grad/Shape" + input: "gradients_2/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_5_grad/Sum" + input: "gradients_2/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_grad/Shape" + input: "gradients_2/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_grad/Sum" + input: "gradients_2/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_5_grad/Shape" + input: "gradients_2/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_5_grad/Sum" + input: "gradients_2/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_grad/MatMul" + input: "gradients_2/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients_2/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_grad/MatMul" + input: "gradients_2/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients_2/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_1_grad/Rank" + input: "gradients_2/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients_2/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_1_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_1_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_3_grad/Rank" + input: "gradients_2/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients_2/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_3_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_3_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_1_grad/Rank" + input: "gradients_2/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients_2/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_1_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_1_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_3_grad/Rank" + input: "gradients_2/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients_2/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_3_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_3_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_1_grad/Pad" + input: "gradients_2/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_3_grad/Pad" + input: "gradients_2/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_1_grad/Pad" + input: "gradients_2/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_3_grad/Pad" + input: "gradients_2/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_16" + op: "AddN" + input: "gradients_2/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_grad/Rank" + input: "gradients_2/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients_2/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_grad/Reshape_1" + input: "gradients_2/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients_2/AddN_16" + input: "gradients_2/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_17" + op: "AddN" + input: "gradients_2/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_2_grad/Rank" + input: "gradients_2/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients_2/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_2_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_2_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_2/AddN_17" + input: "gradients_2/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_18" + op: "AddN" + input: "gradients_2/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_grad/Rank" + input: "gradients_2/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients_2/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_grad/Reshape_1" + input: "gradients_2/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_2/AddN_18" + input: "gradients_2/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_19" + op: "AddN" + input: "gradients_2/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_2_grad/Rank" + input: "gradients_2/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients_2/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_2_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_2_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_2/AddN_19" + input: "gradients_2/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_20" + op: "AddN" + input: "gradients_2/filter_type_0/Slice_grad/Pad" + input: "gradients_2/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_2/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_20" + input: "gradients_2/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_21" + op: "AddN" + input: "gradients_2/filter_type_1/Slice_grad/Pad" + input: "gradients_2/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_2/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_21" + input: "gradients_2/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_grad/stack" + op: "Pack" + input: "gradients_2/Slice_grad/Rank" + input: "gradients_2/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients_2/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/sub" + op: "Sub" + input: "gradients_2/Slice_grad/Shape_1" + input: "gradients_2/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/sub_1" + op: "Sub" + input: "gradients_2/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/Slice_grad/sub_1" + input: "gradients_2/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_2/Slice_grad/Reshape" + input: "gradients_2/Slice_grad/Reshape_1" + input: "gradients_2/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/Pad" + op: "Pad" + input: "gradients_2/Reshape_5_grad/Reshape" + input: "gradients_2/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_1_grad/stack" + op: "Pack" + input: "gradients_2/Slice_1_grad/Rank" + input: "gradients_2/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients_2/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/sub" + op: "Sub" + input: "gradients_2/Slice_1_grad/Shape_1" + input: "gradients_2/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_2/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/Slice_1_grad/sub_1" + input: "gradients_2/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_2/Slice_1_grad/Reshape" + input: "gradients_2/Slice_1_grad/Reshape_1" + input: "gradients_2/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 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_2/Reshape_9_grad/Reshape" + input: "gradients_2/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_22" + op: "AddN" + input: "gradients_2/Slice_grad/Pad" + input: "gradients_2/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_2/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_22" + input: "gradients_2/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_43/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_43/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_43/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_43" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_43/stack" + input: "strided_slice_43/stack_1" + input: "strided_slice_43/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_28/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_28" + op: "Mul" + input: "strided_slice_43" + input: "mul_28/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_33/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_33/shape" + op: "Pack" + input: "Reshape_33/shape/0" + input: "mul_28" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_33" + op: "Reshape" + input: "gradients_2/Reshape_4_grad/Reshape" + input: "Reshape_33/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA_2" + op: "ProdForceSeA" + input: "Reshape_33" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 15 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA_2" + op: "ProdVirialSeA" + input: "Reshape_33" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 15 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_44/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_44/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_44/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_44" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_44/stack" + input: "strided_slice_44/stack_1" + input: "strided_slice_44/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_29/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_29" + op: "Mul" + input: "mul_29/x" + input: "strided_slice_44" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_34/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_34/shape" + op: "Pack" + input: "Reshape_34/shape/0" + input: "mul_29" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_34" + op: "Reshape" + input: "ProdForceSeA_2" + input: "Reshape_34/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_35/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_35" + op: "Reshape" + input: "ProdVirialSeA_2" + input: "Reshape_35/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_45/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_45/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_45/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_45" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_45/stack" + input: "strided_slice_45/stack_1" + input: "strided_slice_45/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_30/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_30" + op: "Mul" + input: "mul_30/x" + input: "strided_slice_45" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_36/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_36/shape" + op: "Pack" + input: "Reshape_36/shape/0" + input: "mul_30" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_36" + op: "Reshape" + input: "ProdVirialSeA_2:1" + input: "Reshape_36/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "o_force/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "o_force" + op: "ConcatV2" + input: "Reshape_26" + input: "Reshape_30" + input: "Reshape_34" + input: "o_force/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "o_virial/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "o_virial" + op: "ConcatV2" + input: "Reshape_27" + input: "Reshape_31" + input: "Reshape_35" + input: "o_virial/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "o_atom_virial/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "o_atom_virial" + op: "ConcatV2" + input: "Reshape_28" + input: "Reshape_32" + input: "Reshape_36" + input: "o_atom_virial/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +library { +} +versions { +} diff --git a/source/tests/infer/deepdipole_new.pbtxt b/source/tests/infer/deepdipole_new.pbtxt new file mode 100644 index 0000000000..4a76d9d79d --- /dev/null +++ b/source/tests/infer/deepdipole_new.pbtxt @@ -0,0 +1,53709 @@ +node { + name: "t_box" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "t_coord" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "t_type" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "t_natoms" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 4 + } + } + } + } +} +node { + name: "t_mesh" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "model_attr/tmap" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "O H" + } + } + } +} +node { + name: "model_attr/sel_type" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "model_attr/model_type" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "dipole" + } + } + } +} +node { + name: "model_attr/model_version" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "1.0" + } + } + } +} +node { + name: "model_attr/output_dim" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "add/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "add" + op: "AddV2" + input: "add/x" + input: "strided_slice" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "descrpt_attr/rcut" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 4.0 + } + } + } +} +node { + name: "descrpt_attr/ntypes" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "descrpt_attr/ndescrpt" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "descrpt_attr/sel" + op: "Const" + 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" + } + } + } +} +node { + name: "descrpt_attr/t_avg" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 2 + } + dim { + size: 552 + } + } + tensor_content: "\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\026h\025\205\216\251?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253>|h\352\334\247?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "descrpt_attr/t_avg/read" + op: "Identity" + input: "descrpt_attr/t_avg" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@descrpt_attr/t_avg" + } + } + } +} +node { + name: "descrpt_attr/t_std" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 2 + } + dim { + size: 552 + } + } + tensor_content: "3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?3\201\031\356M\370\303?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\017\200\307\345\2725\270?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?\032?\235\027\352*\302?\312\036n\226{\024\266?\312\036n\226{\024\266?\312\036n\226{\024\266?" + } + } + } +} +node { + name: "descrpt_attr/t_std/read" + op: "Identity" + input: "descrpt_attr/t_std" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@descrpt_attr/t_std" + } + } + } +} +node { + name: "strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_1" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul" + op: "Mul" + input: "strided_slice_1" + input: "mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape/shape" + op: "Pack" + input: "Reshape/shape/0" + input: "mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape" + op: "Reshape" + input: "t_coord" + input: "Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_1/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\t\000\000\000" + } + } + } +} +node { + name: "Reshape_1" + op: "Reshape" + input: "t_box" + input: "Reshape_1/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_2/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_2/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_2/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_2" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Reshape_2/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_2/shape" + op: "Pack" + input: "Reshape_2/shape/0" + input: "strided_slice_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_2" + op: "Reshape" + input: "t_type" + input: "Reshape_2/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdEnvMatA" + op: "ProdEnvMatA" + input: "Reshape" + input: "Reshape_2" + input: "t_natoms" + input: "Reshape_1" + input: "t_mesh" + input: "descrpt_attr/t_avg/read" + input: "descrpt_attr/t_std/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "rcut_a" + value { + f: -1.0 + } + } + attr { + key: "rcut_r" + value { + f: 4.0 + } + } + attr { + key: "rcut_r_smth" + value { + f: 3.799999952316284 + } + } + attr { + key: "sel_a" + value { + list { + i: 46 + i: 92 + } + } + } + attr { + key: "sel_r" + value { + list { + i: 0 + i: 0 + } + } + } +} +node { + name: "Reshape_3/shape" + op: "Const" + 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(\002\000\000" + } + } + } +} +node { + name: "Reshape_3" + op: "Reshape" + input: "ProdEnvMatA" + input: "Reshape_3/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "o_rmat" + op: "Identity" + input: "Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "o_rmat_deriv" + op: "Identity" + input: "ProdEnvMatA:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "o_rij" + op: "Identity" + input: "ProdEnvMatA:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "o_nlist" + op: "Identity" + input: "ProdEnvMatA:3" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_3/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_3/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_3/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_3" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_1/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_1" + op: "Mul" + input: "mul_1/x" + input: "strided_slice_3" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_4/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_4/shape" + op: "Pack" + input: "Reshape_4/shape/0" + input: "mul_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_4" + op: "Reshape" + input: "o_rmat" + input: "Reshape_4/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_4/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_4/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_4/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_4" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_2/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_2" + op: "Mul" + input: "strided_slice_4" + input: "mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Slice/begin" + op: "Const" + 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: "Slice/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice/size" + op: "Pack" + input: "Slice/size/0" + input: "mul_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice" + op: "Slice" + input: "Reshape_4" + input: "Slice/begin" + input: "Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_5/shape" + op: "Const" + 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(\002\000\000" + } + } + } +} +node { + name: "Reshape_5" + op: "Reshape" + input: "Slice" + input: "Reshape_5/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Slice/begin" + op: "Const" + 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: "filter_type_0/Slice/size" + op: "Const" + 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\270\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice" + op: "Slice" + input: "Reshape_5" + input: "filter_type_0/Slice/begin" + input: "filter_type_0/Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape/shape" + op: "Const" + 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\004\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape" + op: "Reshape" + input: "filter_type_0/Slice" + input: "filter_type_0/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Slice_1/begin" + op: "Const" + 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: "filter_type_0/Slice_1/size" + op: "Const" + 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: "filter_type_0/Slice_1" + op: "Slice" + input: "filter_type_0/Reshape" + input: "filter_type_0/Slice_1/begin" + input: "filter_type_0/Slice_1/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_1/shape" + op: "Const" + 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: "filter_type_0/Reshape_1" + op: "Reshape" + input: "filter_type_0/Slice_1" + input: "filter_type_0/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/matrix_1_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "$qY6 *\275?\037\217\235=2g\326?9G\337\330\337-\346\277\002`r\027\0335\274?\353\003\350\265C\362\324?" + } + } + } +} +node { + name: "filter_type_0/matrix_1_0/read" + op: "Identity" + input: "filter_type_0/matrix_1_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_1_0" + } + } + } +} +node { + name: "filter_type_0/bias_1_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "\364\302\025\212\347\244\326\277\275\343\353\222\\:\000\300U\263\364W6J\346\277\226\223\242\263\277\212\325\277\347\335}\341\346-\361\277" + } + } + } +} +node { + name: "filter_type_0/bias_1_0/read" + op: "Identity" + input: "filter_type_0/bias_1_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_1_0" + } + } + } +} +node { + name: "filter_type_0/MatMul" + op: "MatMul" + input: "filter_type_0/Reshape_1" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add" + op: "AddV2" + input: "filter_type_0/MatMul" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh" + op: "Tanh" + input: "filter_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_2/shape" + op: "Const" + 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\005\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_2" + op: "Reshape" + input: "filter_type_0/Tanh" + input: "filter_type_0/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/matrix_2_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 5 + } + dim { + size: 10 + } + } + tensor_content: "\276H\236c\n#\263\277\227v\3079\221\316\243\277^\340S\367\354\363\321\277\020IQ\213\370\306\316?\264\220H4c\343~\277\212\034\3156\256\261\340\277{\275\212\200a\020\271?\260\324\036\366\3358\261?\376q\340\356\277%\271?\365\010\224\301\315\263\340?+\037\254\335\216\n\330?\2223LO\354\276\236?\021\201.\263\314.\335?8M\374\\f\006\343?\371\204$\347V\215\315\277L\344(H\306\236\204?0\371Q\270\330s\323\277\301\256\360N\335\277\230\277\274~\357\333D\213\333?\231\243\002\232@\213\325\277\n\250\355Nk\337x\277\256K\275\253&P\312\277i\\\"b\340\274\272\277\261\224,\301\013:\312?\206\203\027\255G8\301?\300\364Jx\245\355\325?8\324\277N \320.\350h\276\277\270\"\2506d\373\325\277\014\246J\207:\014\304\277" + } + } + } +} +node { + name: "filter_type_0/matrix_2_0/read" + op: "Identity" + input: "filter_type_0/matrix_2_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_2_0" + } + } + } +} +node { + name: "filter_type_0/bias_2_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\005N\353\341\346Z\364\277\355\'#\007\333\005\350\277l\205\2232,x\315?vw=\351\325\r\325\277<\2231\367$\020\362\277\020\331\241Y\371\202\333?\227\214\370\324\206a\336?\\Fm\261\355\352\352?\202\354,\217\345`\376?\364\250R\233\302\307\356\277" + } + } + } +} +node { + name: "filter_type_0/bias_2_0/read" + op: "Identity" + input: "filter_type_0/bias_2_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_2_0" + } + } + } +} +node { + name: "filter_type_0/MatMul_1" + op: "MatMul" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_1" + op: "AddV2" + input: "filter_type_0/MatMul_1" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_1" + op: "Tanh" + input: "filter_type_0/add_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_3/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_3" + op: "Reshape" + input: "filter_type_0/Tanh_1" + input: "filter_type_0/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_0/concat" + op: "ConcatV2" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/add_2" + op: "AddV2" + input: "filter_type_0/concat" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/matrix_3_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\271D\264H\260\207\322?\207\200\374\241KW\301\277\007`\214\330;Q\274?iO\236\026\2712\337?\343\33295\370\337\257?\254\377\343\021\370\024\274?\201\343\330)r\230\324?`@\243X\177\355\260\277\317\306\255\370\332\315\303\277\324\207G\205\307\304\265\277}\231I&\335\010\313?\006\357\373\036tZ\300?\001\247\237\317\252\362\276\277:(\215\336\232\024\334\277\364\317\2773\306\335\313?\305\n=\007\310/\276\277\355\035\257y\215\251\324?\347\261\217\004v\031\251?\022\373/53\346\321?\254\217\321X\003\273\312?\351\"x6=\310\301?\271\273zV\007\235\336?\035\234\376\004\365)\312?\351\0039\325\237\326\324?,\346v2\031\r\304\277\032\017ub+B\247\277\265\211\355h3\325\275?c)o\2136\362\317?\351\325\364-\325\345\301?[\003eW\311$~\277s\251d}w\004\330\2772\016\001\355\315e\315\277(,k}\306\372\306?1v\016\307\224l\320?\324t{\304\311\342\302\277\023\205\031\355\315\273\324\277>\370\327\353\316\022\323\277pV FC\316\263?\307g\210C\261B\265?\264\263\023v2R\317?\363\201U\214\376\360\331\277V\345\323\026\004\302\343\277\000\266\312S^\370\265\277s\346\33337^\266\277\363 ,\332sF\263\277p\214\256\376\211o\303\277S\000J]L\231\232\277\330\214\324gQ\361\327\277\224\236\363~\302K\312?*JD\265\016\253\300\277\340\375\253\030%\036\262?\223\341l\304\3020\266\277\036u/\037\371\277\323?\263BnKf_\271?\327hH\227\303\213\213\277\307+a\322/&\263\277\207P\'!\355\366\270\277\352\317\314\347.0\320?\255N\233#F\177\306\277\013\216gG\250\'\324?\013\357\206\230}\025\273?\306\2214X\227W\246?\252\257\\}\206A\224?\326#\226K,\033\277?F\277\332\034\322d\317\277\0213o\252\352e\275\277\235\250\242\311\003\331\325\2773\272\026\201\357?\322\277\375\204\214\362\326\374\311?\334\212(\r\331\000\301\277?\262\373\342\221\303\303\277}\313\333\375\323\336\235?L4f\233R\266\310\277\032o\325\215}\224\337?\'\271pSr\"\216?\336\032\'3T.\302?\010\277\343S\251\265\322\277\344\264\320\\\3623\333?\213\240t\206X\022\330\277\032\242\020l\261\327\277\214v\216\356\002\202\276\277\212.\323qA\005\337\277\316\327e\216d\206\334\277W\314\357\353\027\014\305\277\265\014\200:\273\333\321?<\312\3141N\303\237?h\373\263@W\346\241?&\205!\247M\341\341??\305_V\365\033\264?\223\214`\252\203\236\310\277#\277!\353\356\201\341\277\361\361 \272\014\017\311?\021\345\212 \237\276\245?\206C\010\242\036\276\300?" + } + } + } +} +node { + name: "filter_type_0/matrix_3_0/read" + op: "Identity" + input: "filter_type_0/matrix_3_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_3_0" + } + } + } +} +node { + name: "filter_type_0/bias_3_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\373aX\335\305%\321?L\001\276T}\202\353?\2102\006\226\037}\367?d\206\030\234F\021\326?\325\263\350\006\362\002\374\277\230E\021iWC\364?k{hT\010\006\373?\213\264\333\340Q\265\346\277\252\'Ye\325\367\324\277\315\274\362\360T\332\333\277" + } + } + } +} +node { + name: "filter_type_0/bias_3_0/read" + op: "Identity" + input: "filter_type_0/bias_3_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_3_0" + } + } + } +} +node { + name: "filter_type_0/MatMul_2" + op: "MatMul" + input: "filter_type_0/add_2" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_3" + op: "AddV2" + input: "filter_type_0/MatMul_2" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_2" + op: "Tanh" + input: "filter_type_0/add_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_4/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_4" + op: "Reshape" + input: "filter_type_0/Tanh_2" + input: "filter_type_0/Reshape_4/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/add_4" + op: "AddV2" + input: "filter_type_0/add_2" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_5/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377.\000\000\000\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_5" + op: "Reshape" + input: "filter_type_0/add_4" + input: "filter_type_0/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Reshape_6/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377.\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_6" + op: "Reshape" + input: "filter_type_0/Slice" + input: "filter_type_0/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/MatMul_3" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_0/Slice_2/begin" + op: "Const" + 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\270\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice_2/size" + op: "Const" + 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\377p\001\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice_2" + op: "Slice" + input: "Reshape_5" + input: "filter_type_0/Slice_2/begin" + input: "filter_type_0/Slice_2/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_7/shape" + op: "Const" + 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\004\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_7" + op: "Reshape" + input: "filter_type_0/Slice_2" + input: "filter_type_0/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Slice_3/begin" + op: "Const" + 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: "filter_type_0/Slice_3/size" + op: "Const" + 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: "filter_type_0/Slice_3" + op: "Slice" + input: "filter_type_0/Reshape_7" + input: "filter_type_0/Slice_3/begin" + input: "filter_type_0/Slice_3/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_8/shape" + op: "Const" + 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: "filter_type_0/Reshape_8" + op: "Reshape" + input: "filter_type_0/Slice_3" + input: "filter_type_0/Reshape_8/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/matrix_1_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "_6\262r\"B\327?{;\320\367\343\032\326\277\334\3771f\310\354\331?\034s\020\346\247\264\342?\237HHDr\035\254\277" + } + } + } +} +node { + name: "filter_type_0/matrix_1_1/read" + op: "Identity" + input: "filter_type_0/matrix_1_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_1_1" + } + } + } +} +node { + name: "filter_type_0/bias_1_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "\316*\037(\014\177\354\277\255\352\257\034\303^\263\277\310\210\002\234\221$\321?\314\014\035U\335\002\000\300Z\277\234\346\371\232|\277" + } + } + } +} +node { + name: "filter_type_0/bias_1_1/read" + op: "Identity" + input: "filter_type_0/bias_1_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_1_1" + } + } + } +} +node { + name: "filter_type_0/MatMul_4" + op: "MatMul" + input: "filter_type_0/Reshape_8" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_5" + op: "AddV2" + input: "filter_type_0/MatMul_4" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_3" + op: "Tanh" + input: "filter_type_0/add_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_9/shape" + op: "Const" + 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\005\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_9" + op: "Reshape" + input: "filter_type_0/Tanh_3" + input: "filter_type_0/Reshape_9/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/matrix_2_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 5 + } + dim { + size: 10 + } + } + tensor_content: "\200\203\231\014\343\"\301?\251\205iS\213$\267?\363ax\353\'X\267\277\306\355l\363;\223\330?Q\337\272\306@\372\255\277i\342\317e\307\177\260?4\217\262\331PW\227\277\265\237\",\361\331\322\277\276l_\n;\013\255?*\020\3726l\177\323?\021e%\034\367,\244\277\0211\233\006l\010\323\277\\\010\221\235\311V\323\277\272\2407\021y\362\307?\254t\003v\025%\320\277\010A\235\306\221\335\306\277\346\311\023M\231r\264\277~\317mr\316\325\275\277\372.+\250\005\223\337?\007\364\320\031D\343\325?K+\032\036v}\304\277o\027\374\223\"T\326?\336Uf\354\351T\312?\330!O\354\253\244\316?\267V;\342X\037\231?\270\230\0312\'@\313\2775g\022\244\372\324\335?\320\343n\211\006\364\341\277\332!\027L\243d\313?\262\177\030\n\245\2659\277J\0051\363\303Y\351\277\337\001\004\310\212<\327\277\006:\005_\341 \324?\225\005\252b\327\300\332\277S\005X\332!\020n?M\n\321X\254\036\267?wC\017\344,\256\322?\317\317\214\330\025p\313\277\270\305;R|\215\341?cv$\357\036o\273?\314\177\305O\003q\323\277\022q\000S\030S\325?\362\'h\341\345\030\256?\367\'\257I\277B\314\277\324\207\302\315\314\224\301?I\016\241\254\271\242\303?i\365\373)\253\"\257\277H\206\230\241$\341\244\277\352\353\316\362\'\346\277\277\303?5\323\254\276\276\277" + } + } + } +} +node { + name: "filter_type_0/matrix_2_1/read" + op: "Identity" + input: "filter_type_0/matrix_2_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_2_1" + } + } + } +} +node { + name: "filter_type_0/bias_2_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "!\276Dx5\030\353\277\200b\t\024\236K\352?/\373\266^\345/\216?r\034V\240>\002\312?z\3038YT\227\360?N\251X0#\307\377\277\246\363\262U\256\001\332\277\177\347\2145$\215\341?\334\013\252.\276\352\341?~\212D\204\301k\320?" + } + } + } +} +node { + name: "filter_type_0/bias_2_1/read" + op: "Identity" + input: "filter_type_0/bias_2_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_2_1" + } + } + } +} +node { + name: "filter_type_0/MatMul_5" + op: "MatMul" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_6" + op: "AddV2" + input: "filter_type_0/MatMul_5" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_4" + op: "Tanh" + input: "filter_type_0/add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_10/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_10" + op: "Reshape" + input: "filter_type_0/Tanh_4" + input: "filter_type_0/Reshape_10/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/concat_1/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_0/concat_1" + op: "ConcatV2" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/concat_1/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/add_7" + op: "AddV2" + input: "filter_type_0/concat_1" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/matrix_3_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\367\361\255A\233Z\301\277e\0038\336F\224\321\277\333<_\354e\013\320?O\024\357\241\345\266\300\277\026 i\345\305\243\316\277\003\334\\#S\361\324\277]\354\n\273\373\233\264?\225\253\036\'\202\222\270\277\375c\240\256I\251\263\277\220\274\243r\210\272\321?\244 \266/4\024s?\355\216#U^\325\275\277\346\321\225WC\227\316\2778k\2424\010\277\302??T3u\275D\304?X\371\352\220\240\266\224?\245\340\305f\335\205\302?\212\246\370\300t6\254?\361\254\344\301$l\267\277\255\005#o\002\214\320?\257\344\277\256\177E\262?S\247\254G|\275\211\277\n\3410\335\033\340\251\277\220\377b\355\347\030\264\277JF>\t\023U\246\277\017|\036\207Kz\262?\246`\324b\225\025\325?\370\025\005C\356\010r\277X\361*\247\007\273\301\277\340\341\321\243L\013\241\277\tdcRA<\277?R\315\310YXs\331?\320\336\334\256\262\343\302?\360\r\373\2063\263\263\277\312\205\210\316|\026\332\277=\312\341\254tF\320?\3447\220\317)#\303\277\246|^\023\263t\277?\2134\361\341\211\343\310\277\204.X\233]-\331?f\241\001\331\005\306\324\277g\320^\375\276\221\346?\3362lQB\234\214? \327\367\006\337\377\314\277x\207U\267\037\364\332?\332\004\204\347Aj\313?\034\037\304\364\212\017\324? r\241\205\230G\322?a\224\256yBg\332\277\217\262;\217t1\300?\316\021\020e\271G\261\277\326[E\220d\301\240?$\327\261$o,\320?D\262&R\352\203\252?\376\262\316;UB\300?\342\204\2340\345\002\303?\'\007\256^\266p\306\277\036z\230x@I\227\277\200\255q\333\327\236\225?\214\362?\025\374\326\312?\331\006L]\374\235\310?\244\000\302\007\035x\305\277\003\364\324\244\365k\313\277\366=\275\224\237\360\333\277A\347\233\0166j\310?~t\212\352\004c\323?\364\270rv\316F\320?\017`\266\257\261\350\'\277\275]Z\"R\001\335?\277ts\344\217\354\262\277\014\222\347\300U9\340?\300n\201_>\252\300\277\311\020\017;\337\254\264\277\342?\2012m \330\277g\201>U#\007\273?\'DB\017\017\245\260?\327\035\334g\330\355\311?\230!\001\220\264l\304\277\336/\257\260\3700\320\277\265\306\243c\363?\341\277c\273\006|t\302\260\277\352\310\251\301\350\000\322?\360S\337 \"\277\311?\316>\251\223/W\300\277<(/\260T\340\270\277\'\223\375:\207N\325?\010\014\252\250\224\233\344?\277xQ\324\003\356\267?\005\r\n\323\016\r\325\277\374#\314\2118\271\315?mi\204\360\316|\211\277\256\332e&N\013\327?\010n\343\223\027\007\261?1>\237Z\204\361\277\277@0O\253\303\207\325\277y\354\257\246\227\206\340?\213\255\301\257\3323o?\0013\345\027\036\336\314\277{\032\323\177*(\312\277\267\027\366\375\257\n\310?" + } + } + } +} +node { + name: "filter_type_0/matrix_3_1/read" + op: "Identity" + input: "filter_type_0/matrix_3_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_3_1" + } + } + } +} +node { + name: "filter_type_0/bias_3_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\274C\270\004K.\372\277C1r\202\324\314\366\277JS\212\001\211\274\263\277\337\233\323R5I\347\277\032\371\026\261\035\\\332\277\336\337\316\300\225\302\364\277E\266W]?S\345\277\253\270\251\306\247\216\346?7w\231j\225%\341?\2624b\315\316&\320?" + } + } + } +} +node { + name: "filter_type_0/bias_3_1/read" + op: "Identity" + input: "filter_type_0/bias_3_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_3_1" + } + } + } +} +node { + name: "filter_type_0/MatMul_6" + op: "MatMul" + input: "filter_type_0/add_7" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_8" + op: "AddV2" + input: "filter_type_0/MatMul_6" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_5" + op: "Tanh" + input: "filter_type_0/add_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_11/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_11" + op: "Reshape" + input: "filter_type_0/Tanh_5" + input: "filter_type_0/Reshape_11/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/add_9" + op: "AddV2" + input: "filter_type_0/add_7" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_12/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\\\000\000\000\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_12" + op: "Reshape" + input: "filter_type_0/add_9" + input: "filter_type_0/Reshape_12/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Reshape_13/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\\\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_13" + op: "Reshape" + input: "filter_type_0/Slice_2" + input: "filter_type_0/Reshape_13/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/MatMul_7" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_10" + op: "AddV2" + input: "filter_type_0/MatMul_3" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/mul/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 0.007246376811594203 + } + } + } +} +node { + name: "filter_type_0/mul" + op: "Mul" + input: "filter_type_0/add_10" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Slice_4/begin" + op: "Const" + 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: "filter_type_0/Slice_4/size" + op: "Const" + 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\377\377\377\377\006\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice_4" + op: "Slice" + input: "filter_type_0/mul" + input: "filter_type_0/Slice_4/begin" + input: "filter_type_0/Slice_4/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Slice_5/begin" + op: "Const" + 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: "filter_type_0/Slice_5/size" + op: "Const" + 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\003\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "filter_type_0/Slice_5" + op: "Slice" + input: "filter_type_0/mul" + input: "filter_type_0/Slice_5/begin" + input: "filter_type_0/Slice_5/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/transpose/perm" + op: "Const" + 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\001\000\000\000" + } + } + } +} +node { + name: "filter_type_0/transpose" + op: "Transpose" + input: "filter_type_0/Slice_5" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/MatMul_8" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_0/Reshape_14/shape" + op: "Const" + 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<\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_14" + op: "Reshape" + input: "filter_type_0/MatMul_8" + input: "filter_type_0/Reshape_14/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_7/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_7/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_7/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_7" + op: "StridedSlice" + input: "Shape_1" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_8/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_8/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_8/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_8" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_3/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_3" + op: "Mul" + input: "strided_slice_8" + input: "mul_3/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_7/shape" + op: "Pack" + input: "strided_slice_7" + input: "mul_3" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_7" + op: "Reshape" + input: "filter_type_0/Reshape_14" + input: "Reshape_7/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Shape_2" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_9/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_9/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_9/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_9" + op: "StridedSlice" + input: "Shape_2" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_10/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_10/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_10/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_10" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_4/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 10 + } + } + } +} +node { + name: "mul_4" + op: "Mul" + input: "strided_slice_10" + input: "mul_4/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_5/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_5" + op: "Mul" + input: "mul_4" + input: "mul_5/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_8/shape" + op: "Pack" + input: "strided_slice_9" + input: "mul_5" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_8" + op: "Reshape" + input: "filter_type_0/transpose" + input: "Reshape_8/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_11/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_11/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_11/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_11" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "add_1/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "add_1" + op: "AddV2" + input: "add_1/x" + input: "strided_slice_11" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_6/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_6" + op: "Mul" + input: "add_1" + input: "mul_6/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_12/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_12/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 4 + } + } + } +} +node { + name: "strided_slice_12/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_12" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_7/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_7" + op: "Mul" + input: "strided_slice_12" + input: "mul_7/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Slice_1/begin/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "Slice_1/begin" + op: "Pack" + input: "Slice_1/begin/0" + input: "mul_6" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_1/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice_1/size" + op: "Pack" + input: "Slice_1/size/0" + input: "mul_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_1" + op: "Slice" + input: "Reshape_4" + input: "Slice_1/begin" + input: "Slice_1/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_9/shape" + op: "Const" + 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(\002\000\000" + } + } + } +} +node { + name: "Reshape_9" + op: "Reshape" + input: "Slice_1" + input: "Reshape_9/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/Slice/begin" + op: "Const" + 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: "filter_type_1/Slice/size" + op: "Const" + 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\270\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Slice" + op: "Slice" + input: "Reshape_9" + input: "filter_type_1/Slice/begin" + input: "filter_type_1/Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape/shape" + op: "Const" + 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\004\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape" + op: "Reshape" + input: "filter_type_1/Slice" + input: "filter_type_1/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/Slice_1/begin" + op: "Const" + 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: "filter_type_1/Slice_1/size" + op: "Const" + 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: "filter_type_1/Slice_1" + op: "Slice" + input: "filter_type_1/Reshape" + input: "filter_type_1/Slice_1/begin" + input: "filter_type_1/Slice_1/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_1/shape" + op: "Const" + 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: "filter_type_1/Reshape_1" + op: "Reshape" + input: "filter_type_1/Slice_1" + input: "filter_type_1/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/matrix_1_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "\303\232\"W\250z\307\277\001t\325\320/\211\345?\000M8\315\315\251\272?\204\210\242h\020\017\222\277\224g\266qL\314\335\277" + } + } + } +} +node { + name: "filter_type_1/matrix_1_0/read" + op: "Identity" + input: "filter_type_1/matrix_1_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_1_0" + } + } + } +} +node { + name: "filter_type_1/bias_1_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "\230\325\2407\274\331\330\277\244\326\356\274\247\035\337\277\212v\302\216\311R\353?\303\307\031\024\344\303\271?eD\207\371\257R\326\277" + } + } + } +} +node { + name: "filter_type_1/bias_1_0/read" + op: "Identity" + input: "filter_type_1/bias_1_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_1_0" + } + } + } +} +node { + name: "filter_type_1/MatMul" + op: "MatMul" + input: "filter_type_1/Reshape_1" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add" + op: "AddV2" + input: "filter_type_1/MatMul" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh" + op: "Tanh" + input: "filter_type_1/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_2/shape" + op: "Const" + 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\005\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_2" + op: "Reshape" + input: "filter_type_1/Tanh" + input: "filter_type_1/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/matrix_2_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 5 + } + dim { + size: 10 + } + } + tensor_content: "\353\n\021\301\004\'\316?Z\324\200\203\353J\301?\2245\263\027QJ\332?\264C\212\253\272A\326\277\341\0168\341d\207\344?\340\244\n\210n\221\274?\352y\261\320\r\034\314?\302\034\226Y\375z\270\277\3570i\361\3655\340?qc[B\2743\224?\263\306\023\325Q\005\323?\335\230\213\216O\200\274?fb\347e\271O\263\277\360J\034p%\265\262\277\371\245\361\302\267]\330\277\356\231$\306I}\312?\334\354\244\274\321;\310\2774\206|+\027;\326?\232;o\224\306\356\317?\217\nrL\226\363\265\2774\237\221\206\000\364\322?{\335\361\325\302*\272\277y\312\212Q\313\275\337\2779\177`6\007V\300\277=\"J#\366\016\322?\007b\032\2475\177\242\277;v\371\334Us\262\277\n^y\315\354_\304?I\314mEA\343\200?\327\374\347r\271\276\312\277\031\211;\270\241\227\276?\031\034P\372\033\007\315\277v\257\n?\316v\301\277\241\222\261\325:-\303?Ef\"\017\303\024\300?\004\205cu?\345\306\277\330G\027\303\2153\301?\273m\335\013\025X\326\277\263\311_\231\330\344\324\277Q\261\317\333g\226\332\277(\356\334\377\242$\243\277v\235\315\372\336z\301\277\220E \232\035\200\273\277\350Y\315\013!v\276\277\250\332\007\221/B\261\277+\345]Y\274\024S\277V\333@)L~\324\277\233k\250\264%W\323\277P\037\362\021^\016\303\277(\002\r\023\320x\337?" + } + } + } +} +node { + name: "filter_type_1/matrix_2_0/read" + op: "Identity" + input: "filter_type_1/matrix_2_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_2_0" + } + } + } +} +node { + name: "filter_type_1/bias_2_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\371\203E\253\275z\345\277\255\327\375\306\231a\320?\n\t\237\336\202t\336\277\233fh\246V:\327\277\213M\250\230\373\340\342?\247\307\177\360\276\033\346\277\265\036g$\222\343\363\277\372\ty\325\265\007\304\277\367J0Is\357\255?\333A\245\274vc\340\277" + } + } + } +} +node { + name: "filter_type_1/bias_2_0/read" + op: "Identity" + input: "filter_type_1/bias_2_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_2_0" + } + } + } +} +node { + name: "filter_type_1/MatMul_1" + op: "MatMul" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_1" + op: "AddV2" + input: "filter_type_1/MatMul_1" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh_1" + op: "Tanh" + input: "filter_type_1/add_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_3/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_3" + op: "Reshape" + input: "filter_type_1/Tanh_1" + input: "filter_type_1/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_1/concat" + op: "ConcatV2" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/add_2" + op: "AddV2" + input: "filter_type_1/concat" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/matrix_3_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\027\321\300z,\n\276?\204\322N\276\321\336\210?\t\031\002\274\006\242\277\277R\323\317\016\323E\301??\336\302k~n\271\277\021\251\227\305\003\222\266\277s\211\205\376\240\260\336?\372h\264\202\'\271\261?xWP\346 \345\304\277\262\005\374a\340\266\311?Rl\250h\222\230\227?\0142\316\274\313\224\254\277\002\372\377\206\265\234\224?W\323\256y\312\032\330\277\025\343\363\255\367J\342?\251\307\321\027\004@\210\277\371\226s\210\201\257\313\277\227\277\251\274Fy\326?7\301\340e\002\261\323\277LfE\266\225\320\254?\230\204\235\355Pe\313?r\373\263\265Bj\320\277\332\010\265\226B\017\267?\352\226\200\241b\327\256?0\010\240H\322\257\240?a\274\013!)\322\301\277\206\302\323\334\212F\342?\311\027:\367\321\034\330?\375\261}CS\322\254?_\356uA\224\021\301\277\333H\347Sw\304\320\277\026\000\245\334\266\366\333?\002\375\237|\330^\250?\202\333\246N\030LU\277f\340[\033\030=\275?\013\005\355\355\265h\340\277\200;\241\206\332\371\277?}\300s.\325\274\267\277\254}R\376\257\372\305?\202\355\215\220B}\321\277%A\333l\003\265\231?Z\315\227\353\353I\337?\343\266\235w\203\246\320\277\346D\200\236\212\306\325?Yf\205\007\276\370\267?\272YM\034h4\330?!\351\273\216\220\314\331\2773\220\230$*\212\305?^\314\243l\277\244\307\277\351\344\361[V\242\337?\241\3541\245l\363\256\277\016\014\265\357%\317\265?\017$\357\030\252\215\177?\245\r \000\364\250\264\277\347\330\213\246\207\373\326\277\276\320\322\256\365\037\313?\274\021[\205\305\227\276\277\232\207q\275\321\230\267\277\333\264\037-\315\374\326?\030\3771f\3354\300?\3418\026\231\262&\205?\225\221p\372\244\212\301?\271\252Se\210\205\320?\354XB\261e\250\321\277\241\220\210\346\325I\304\277\307\375\235p\300\016\275?e\032\026%\234\034\337\277\201\215\365\330\315\"\300?nr\0109\265\270\237\277\240r%*\313\237\327\277F\013p\371\206\266\332\277k\375\364j\257T\200?\305d\3741t\372\325\277\210)\002\n\340\343p?\204\030\336\nB\235\305\277\033u:\000~\n\321\277\222\217B\212\361\311\334\277~7&\037.Z\315?\010\214Xl\027#\277\277\276&\335\235\037\223\260\277\267\300\030\270\240Z\274\277\373\201*\313qV\316\277\337=w\256\030\337\311\277\211\032\3632\223\032\313\277\375\304\335G\324Y\307\277\025\360A\206\364e\303\277\006\374\007+\323\'\201\277\203\351\255\333\200\333\264\277\253[\353\273\321\325\330\277\230\243W\033\355\235\262?r\031bp\200\313\252?\332\212z\226\226\223\316\277:\257\374\003\n~\305\277{\376\256}(\262\264?W\207j\017g,\307?\226\302GF\265o\302\277\347\332l\330\364\253\316\276\325?t\311\\\323A\0136\277\003\030\234\331\301\265\303?\351\004\221Xf\251\334\277jO\244\0033f\271?\211\010\312\010\255E\342\277\261\227\277\347\216\327\267?\324\315\3204\364\017\305\277\3532L\007\266\355\266?\3007\237\300\020H\337?\017mGL\352\344\324\277\222\362\030y\302E\314\277\210\315\036\223\363Q\240\277\313\201\023)nE\313?\3121\243\007mV\336\277+\336\211\036\226\323\261?\324#\032&\355\345\305\277\341\245\347\002\363\217\312?v\317\207\024W<\306\277\362Y\276\311\372+\257?\257\205\252\252\221\345\247\277\026\201=\220\341\327\301\277\235\345+\242w\331\313\277N\274Q\220,g\307?\326\323\335\265\263-\262\277\310P\376~Xe\257\277\324[_\356\017\026\337?/\334oG\017j\302?k\032\006\3707Z\300?7\264\024\317\346\203\322?\233\204\201\320\004=\277\2772/%\213H\354\316?\250>\363\342\017\304\274?t\364\231\023c\177\257?\212_^2\346\204\277?\tR5{\364\370\263\277Rr\206=:\252\251?&\332\221\332Tw\323\277" + } + } + } +} +node { + name: "filter_type_1/matrix_2_1/read" + op: "Identity" + input: "filter_type_1/matrix_2_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_2_1" + } + } + } +} +node { + name: "filter_type_1/bias_2_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\274D\221<5\027\325?\365\340\322\001Wq\352?\227\000.\002\254\256\200\277C-0\305\037\214\225?\250\204\355\t\220\030\363?\373\324h\010\335\032\262\277\263s\300\236\312\036\311\277\342\221\220\353k\316\352?=\372-\033\3244\363\277\010\245\276\370|\235\357\277" + } + } + } +} +node { + name: "filter_type_1/bias_2_1/read" + op: "Identity" + input: "filter_type_1/bias_2_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_2_1" + } + } + } +} +node { + name: "filter_type_1/MatMul_5" + op: "MatMul" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_6" + op: "AddV2" + input: "filter_type_1/MatMul_5" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh_4" + op: "Tanh" + input: "filter_type_1/add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_10/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_10" + op: "Reshape" + input: "filter_type_1/Tanh_4" + input: "filter_type_1/Reshape_10/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/concat_1/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_1/concat_1" + op: "ConcatV2" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/concat_1/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/add_7" + op: "AddV2" + input: "filter_type_1/concat_1" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/matrix_3_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\232\3337\000\216\336\271\277\022$\013%Gf\322?\\Gd\017\211P\301\277J\227\341h\317R\252?e\244\376^,V\244?\311\202N(\032\001\277\277:\365z\321n\002\333\277>0\345ge)\311\277\231-akv|\313\277\r\302\240\265O\306\311?\312\261H\006\270t\270\277\203\355?D\256/\313\2774\022\002PB+\300\277\361\227\032\307\306\360\227?\363y\305\373;j\200\277w\332\356\2750\\\302\277y0\212?O\322\260?\232{+\030\326\306\320?\311\331\221\262\t2\327\277\010\240\224GH*\334?\007\345\032\005\034\273\260?]W8}\341\364\257\277\374\351\354\377\271\032\274\277m\027\257n\0012\323\277+\217\365D\320$\312\277\301\252\265\302\343x\316\277\201B\357\215\333\245\231\277\000\227h\275\033`\320\277\324w\353\2423\027\313?\035\221w\242\003$\322\277\202\226\353d\265\300\273\277uk[\022Ny\331\277\314\275 \363\243\307\301?6P\372\314\263\002\300?\347\353\211\230\260t\242?\327\312\204\031\212\231\311\277-\310\023\220\023\307\301?\345\255\326\330\002\211\252?\200\205\002\373\302\222\304\277z\263\245\007=\234~?\tM\321\202l\374\272\277\r\330\200g\200\265\313?\212\032h\262B\266\302?)\207ivC\'\305\2775\0277\033I\273\320??N\367\341:\261\211\277\007\261\334\220\034h\315\277\006\240\336\214x\325\264?Se\274{f\205\324?Z\353\370o\001\313\265\2777^\211\366\215\010\270\277\224#<\366\374\322\267?;x\371\201\005X\262\277\374\\\201Y\222\307\276?t\245\335t\273M\265?\343&\3034E5\325?\317Z\336(\323\013\301\277SJ6\t\013c\273?\020<\376n;[\307?\205\000\323\264\301\\\267?:\300\244\374S\343\300?i?D\305\375~\340\277K\233\315`\014\242\300?.,\002\347([J?\2612\363O\320\242\334\277rt\304\013e\363\320\2773\340\241\277\252\212\332?\333\026\025z\352\251\327?NW\272\344.R\317\277\316qau\0066\340?l$\266c\351\233\265\277u\363j\227\243-\272?\005\323h\362FM\226\277\202Z\355a\006\250\273\277\270\302\326*\341\321\262?\355\345SVh\024\260\277\274\217\223`\343\270\317?\255\t\251\033C\"\335\277\026R\244~\364\272\303?\372\355\265\233\302\305\342?YQ\316[\306\302\332\277\226o\310\311iH\316\277q\277\316\303u\240\311\277\357W}?\375 \311\277\344\002\020\251\2039\315?j\261:\225\3318\266\277B\351\3533F$\263\277e=\327K\017+\237\277\310\242\334\\bd\335?\345\220\233\005\357\227\274?\3050\002\223\335r\262?\204\217\270\204\210\231\322?\242K\263\007s/\322?\206#x\324\027\303\321\277\022<$\325f\317\316?zsS\312\266U\333\277\2647\0131\nd\267\277\027\342\324\300kJ\301\277\244\025\n\263q\001\275\277\274\211\323\365\330\247\311\277" + } + } + } +} +node { + name: "filter_type_1/matrix_3_1/read" + op: "Identity" + input: "filter_type_1/matrix_3_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_3_1" + } + } + } +} +node { + name: "filter_type_1/bias_3_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "j\t\326\260\252\034\353\277\203WH\271\262\341\320?8\322\330i\317S\352\277\013\355\317\261g\236\345?\030\205\221\251E{\350\277L\031\213]\014Os\277z\226\224\226\320\272\323?\210\244\214\302o\223\356?\031\037\302\303\001k\340?\350C\026\022T\034\327?" + } + } + } +} +node { + name: "filter_type_1/bias_3_1/read" + op: "Identity" + input: "filter_type_1/bias_3_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_3_1" + } + } + } +} +node { + name: "filter_type_1/MatMul_6" + op: "MatMul" + input: "filter_type_1/add_7" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_8" + op: "AddV2" + input: "filter_type_1/MatMul_6" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh_5" + op: "Tanh" + input: "filter_type_1/add_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_11/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_11" + op: "Reshape" + input: "filter_type_1/Tanh_5" + input: "filter_type_1/Reshape_11/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/add_9" + op: "AddV2" + input: "filter_type_1/add_7" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_12/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\\\000\000\000\n\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_12" + op: "Reshape" + input: "filter_type_1/add_9" + input: "filter_type_1/Reshape_12/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/Reshape_13/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\\\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_13" + op: "Reshape" + input: "filter_type_1/Slice_2" + input: "filter_type_1/Reshape_13/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/MatMul_7" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_10" + op: "AddV2" + input: "filter_type_1/MatMul_3" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/mul/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 0.007246376811594203 + } + } + } +} +node { + name: "filter_type_1/mul" + op: "Mul" + input: "filter_type_1/add_10" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Slice_4/begin" + op: "Const" + 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: "filter_type_1/Slice_4/size" + op: "Const" + 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\377\377\377\377\006\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Slice_4" + op: "Slice" + input: "filter_type_1/mul" + input: "filter_type_1/Slice_4/begin" + input: "filter_type_1/Slice_4/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Slice_5/begin" + op: "Const" + 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: "filter_type_1/Slice_5/size" + op: "Const" + 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\003\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "filter_type_1/Slice_5" + op: "Slice" + input: "filter_type_1/mul" + input: "filter_type_1/Slice_5/begin" + input: "filter_type_1/Slice_5/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/transpose/perm" + op: "Const" + 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\001\000\000\000" + } + } + } +} +node { + name: "filter_type_1/transpose" + op: "Transpose" + input: "filter_type_1/Slice_5" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/MatMul_8" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_1/Reshape_14/shape" + op: "Const" + 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<\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_14" + op: "Reshape" + input: "filter_type_1/MatMul_8" + input: "filter_type_1/Reshape_14/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Shape_4" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_15/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_15/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_15/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_15" + op: "StridedSlice" + input: "Shape_4" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_16/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_16/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 4 + } + } + } +} +node { + name: "strided_slice_16/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_16" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_8/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_8" + op: "Mul" + input: "strided_slice_16" + input: "mul_8/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_11/shape" + op: "Pack" + input: "strided_slice_15" + input: "mul_8" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_11" + op: "Reshape" + input: "filter_type_1/Reshape_14" + input: "Reshape_11/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Shape_5" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_17/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_17/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_17/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_17" + op: "StridedSlice" + input: "Shape_5" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_18/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_18/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 4 + } + } + } +} +node { + name: "strided_slice_18/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_18" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_9/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 10 + } + } + } +} +node { + name: "mul_9" + op: "Mul" + input: "strided_slice_18" + input: "mul_9/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_10/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_10" + op: "Mul" + input: "mul_9" + input: "mul_10/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_12/shape" + op: "Pack" + input: "strided_slice_17" + input: "mul_10" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_12" + op: "Reshape" + input: "filter_type_1/transpose" + input: "Reshape_12/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "concat" + op: "ConcatV2" + input: "Reshape_7" + input: "Reshape_11" + input: "concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "concat_1/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "concat_1" + op: "ConcatV2" + input: "Reshape_8" + input: "Reshape_12" + input: "concat_1/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "o_descriptor" + op: "Identity" + input: "concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "o_rot_mat" + op: "Identity" + input: "concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "strided_slice_20/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_20/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_20/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_20" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_11/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_11" + op: "Mul" + input: "mul_11/x" + input: "strided_slice_20" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_13/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_13/shape" + op: "Pack" + input: "Reshape_13/shape/0" + input: "mul_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_13" + op: "Reshape" + input: "o_descriptor" + input: "Reshape_13/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_21/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_21/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_21/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_21" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_12/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 30 + } + } + } +} +node { + name: "mul_12" + op: "Mul" + input: "mul_12/x" + input: "strided_slice_21" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_14/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_14/shape" + op: "Pack" + input: "Reshape_14/shape/0" + input: "mul_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_14" + op: "Reshape" + input: "o_rot_mat" + input: "Reshape_14/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_22/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_22/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_22/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_22" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_13/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_13" + op: "Mul" + input: "strided_slice_22" + input: "mul_13/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Slice_2/begin" + op: "Const" + 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: "Slice_2/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice_2/size" + op: "Pack" + input: "Slice_2/size/0" + input: "mul_13" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_2" + op: "Slice" + input: "Reshape_13" + input: "Slice_2/begin" + input: "Slice_2/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_15/shape" + op: "Const" + 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<\000\000\000" + } + } + } +} +node { + name: "Reshape_15" + op: "Reshape" + input: "Slice_2" + input: "Reshape_15/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_23/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_23/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_23/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_23" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_14/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 30 + } + } + } +} +node { + name: "mul_14" + op: "Mul" + input: "strided_slice_23" + input: "mul_14/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Slice_3/begin" + op: "Const" + 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: "Slice_3/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice_3/size" + op: "Pack" + input: "Slice_3/size/0" + input: "mul_14" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_3" + op: "Slice" + input: "Reshape_14" + input: "Slice_3/begin" + input: "Slice_3/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_16/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\n\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "Reshape_16" + op: "Reshape" + input: "Slice_3" + input: "Reshape_16/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_0_type_0/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 60 + } + dim { + size: 10 + } + } + tensor_content: "\027\025\256\217q\261\247\277\265B\250\206,k\261\277\003\364\341\252\224]\306\277A\024\251\331\030g\205?\2370U\0004\354\265?\336\177Sb\010\334\225?\310\215+\027\312\354\225\277sVS\032Q\316\306\277O\375\250f\'Q\305?[\367Cj[\314\243\277\274\306\004\010hA\226?\316\273\000\275\362b\255\277*\007?\325\355g\220?\002\253\001\034]#\277?\265\034m\221\327H\310?)\354\014\035\2021\310\277\251\317\300\272[$\270\277e]\326qB9\317?\227\036at%\277\227\277}\010r\032\342\237\270\277zh\262\024D1\217?\363\247M\312}\311\245?\244b\364\034.7\251\277\246\270@\262Z\305\207\277\037\024\277\316\004\031\315\277\240Y\310\320\217i\274?\'\246e\254V\026\254\277\264\262>\225I]\312\277\307\377\362\254!\243\224\277\270\224\t\370,\022\224?\335\376\254rp\357\304\277\243a\352\n\365\227\262\277\227\374%*\\p\266\277\235\321#\263\312\316\272\277\262V\260F\275\"\317\277\325\233\001\004D\206\215?J\003\033-T\215\262?:\001+\021\'\257\247?\310\317\236K\365n\265?\271K\336HY\344\253\277Y\205\177l\333k\304\277Ne\027\375\250;\306?\001\253G\374\3202\315\277(\035\030\320\020\230\230?~\325}oIe\254\277l~\351\032~\356\227?\014\200\3726}\312\316\277\016\330\213\250\301\334\300\277\374=K\227^\375\313\246\277\021\361s\261t\260\301\277V\263%i\240\000\207?\005d\033\027?\370\177?\276\346{\206\223\037\273?\306\265\372\252\014~\321\277Zk\225\260\225\333\272\277\366/u\231\326d\317?\205\020\203\366\263\356\307?;hp\263\037$\311?\330\342\233\204t\354\244?\221\252\036y\245bw?\3305_\000\201v\303\277a\350K\230\302\222~\277u&\253\030\352\340\312?\210\302\017=\235\013\303?\333?\274\017\245q[?\360\020\351\261\234)\306?I\246\025\335]*\276?S\337\323\263-\322\266\2774*\251\'m\224\276\277\354v\"\234\007\345\245\277\311h\312\210\t\253q?\2723\371\334\236\320\276?G\352\364;)\365\305\277U\267c;\313\244e?Q\016\344F\320n\302?\241\376\025\005\307)\305?\245l\315\341\300H\307\277~\336\322\353\265\303\251?\376\237A\222(\262\177\277\364\232\177\230\026\313\307?Wf\370\261\235\250\267\277wy+\222X\200\300?\205\346S\272\364\235\313\277Y\026m\223p\333\314?\350W\210w\365\355\322\277\2421\311\253ug\310\277&B\020;|\235\261?V\215H\ng\004u\277.\372\240\201\332\032\272\277\371+\021\237\342\322\265\277I\207\023M\362\220\311?zfo\370\t\275\217?R\270u\360\350\022\323\277T.!K\236\205\306\277\240\352\310\241[p\266?*1\375\367\rp\266?\367=\233*\211z\312\277\0136gw\211\320\177?`2\201\203\303\263\266\277\260\215\366\026\323\033x?\020/\211\347R\301{?X\n\023,s(\245\277\204\352X\344\t\024\303?c\304\257f=\026\266\277\204\024\361Q<\303\301?\255\307\002G\376\374\262?\241_\264\314\212c\245?Q+\251\333:\365\251?\220\200\351\324\326\277\177\277\213\2549\336\223\311\300?h|\277\226\252_\272\277\201\025\0376\226\332\241?\266\374\252\t\363\352\237\277\004\031N\331\354P\302\277\364\001\275*^!\267\277Kv\201\331/\310\315\277\235U\337\003\266\305\266\277\003/\342\307\004C\257?L\261H\275\211\304\302?\334\025\tt\353.\315\277~\354b\377Z\254\307?,\377\312\n+\t\301\277 \245\177ie\210\211?\271o1-(\255\250?\303\377D\347sd\241\277l\357\331J\227\277\270\027\246\333^H\232\277\006,Z\217\325\240\320? h]\024[\332\243?~\354r\270\311\027\264?\2521\366}J\321\203\277\342\352;O2\254\261\277\321\240R\267\277\217\244\277}\013\030\"\2256\235?k\244\000\366\343\306\303?pf\261uOa\324\277\266yh.\007\315\246?u\237U\237hY\312?s\245s\"\376\254\326?x\260C|,\\h?\340\214J\204\023\351\256?\344\203\242~\271\323\305?_=\021P\355\003\244?\340>m\324,?\303\277\335\374\365\305\242z\306\277+\315\005\214 rT\277\033i5\270\344\230\244?\234\225\332UHP\262??\352\020\230w\372\255\277%\ro\214:)\304\277\223\326^\367F)\271?\021^\037q\356c\272?\033F\356\353\270\034\261?\234X\344\2219\325\302\277\226\265\302\267%\\\253?\376\206\347\226\320\036\317\277\232\375\177Y\224\034\304?O[\310a\331\270\256\277\270T5\236\275Z\306?\335\3541\331P\203\252\277\241\217\325\372\237\220\267\277m6\374\312\266\022\304??\307e\313d\207\246\277\022\216\226\230\026)\261\277\3543\314M\'\020\257\277e@\213\371qS\222\277\254\2412\324\323e\275\277\2409\314r\037\234\223\277\257\213\236\311G\226\267?wT\t\264\353,\252\277\260\020\027e4\254\260?K$L$\357\276\304\277\257\016\r\227\373\002\246?4\222v\244\300\270\324\277\326\007\370:\306d\263\277\360\023\032\363z\217\216?\"\307\333\362|\275\247\277\235\027\225T!/\312?6\317\350m?c\276\277\t\231\\d\320\362\302\277\245L{2\250E\250\277\351~\215\232\t-\306\277\233\375\204\365\231\327\251?O\\WCA4\304\277\253W\236\374\214w\252\277W\320\365\'\351\254\261?u\016\264\224\023\302\271?\256\247s\260X\003\275?\036\325K\346I\205\270\277mTNy\214i\265?\004\004N\\\242w\263?\372\242B\355\nB\312\277\004\2664\212\037\023\306?\215\2521\003X \261\277\020\313!\245W\030\322?\033o\317\032\324\325\301\277Nc\226\345\310\362\313?\343\205>u \225\265?V\314f\251\206\242\266?&^\264\202\222*\301\277auC\377\316(\300?\341\031.\367\022\345p?\310\326mlH\326\247?\274\357\206\363\224[\322\277mr\177A\342\235\263?\251\347\340\212\324\217\300\2776\002\252@\007\221m?/\324Kt\227\322\240?\377\265\3334dH\252\277t\320\230\024\023(\214\277\342\316\217\207\366P\300\277\232?i\250h\231\302\277\222\341\242\334\'\334\315\277\236\251\221\211x\331\257\277\377F\255h\362\004\315?\023\313\215\tj\231\211?ew}-\262)\303?\367/\366\331v\272N\277g\023\005u\332\365\257\277\260{Y,\241\021\317?i\241n\361\374T\223\277\226\314\0013\0326\324?\2460c\247\245e\317\277\261\203zG\256?\260?{A3\205\357;\243\277=\253\247\351D\362\270?\225\336L\0334\315\266\277;\333\227vL\010\302\277\307\t\313\263\274\027\271\277T\366+\215\273\355\300\277\203r\275\332\316\300\240\277\352u\000\332k\212\260\277W\317\371\353d\240d?\004\257\370\031\255\211\324\277\000[\253@\217Z\305?\247\005,\303*\231\304\277\222\020\261=Dd\312?\353@O\021\277\267\265?kG\302a\276\014\306?\031Rj\2025\005\272\277z\261X\261\315r|\277E\343\214\244\347Q\254?\232\313c`S\360Y?R\337\326\343\275\027\312\277\373\255\262\266\222\356\246\277\260EM\007\022\221\275\277\217\337\221\267j\340\304?\204!\021\305\207\355\262?\302d+8<\252\311?\311\311(\325P!\270\277m1\362qz\374\277\277L\272\263\022\230\007\301\277\341P\000\000\363\006\276?\327h\211\256\311\204\242\277N\221\215,B\300\251?\326Eh,\343\204\317\277dOJ\024R\361\274?W%\'|~}\222\277h\035Y\254\033\370\241?\"\2035\264\014\210\300\277<\217\331\345f\353\220\277+\002\265J+\217\277?\246\261j_/r\313?\002\231\013\345kO\322\2770\260\267G\033c\260\277\272\017\033|\204\316\227\277\271}\260\002\3102\322?\035\221\307\337I\276\273?>\327Q\256\212\345\305?\371\254\210\"\217\272\277\277j\206g\001\024\216\252\277\324\3402UB\350\237\277\214\316m6\224e\250\277j\341\357\211\013\211\246\277\2317\321\306ao\236?\323\222\312\361\250?\314\354\305\226\230v\274\277%\254\035\273\244a\300\277 \365\0217\024\260\204?\316*\321\341\024r\215?}\337ZVL\222\315\277\007\024\266\277X\226\274\034\334&\244\277#\021r\\\006\322\203\277\357\320S\027\227\337\313\277\245\255\367\313\371O\314\277^J\371\217\007C\227?*k\247\000\260\226\317\277\333^\014-,~\264?kZ*\251\016Z\243?t\352\237\017\223\351\234\277\030uH\260\366\361\240?\010_|\370\254\222\267\277b-Fu\325\320\205?f\"\2541\223\361\261?\276\3234\204F\027\201?\016\372X\236\275\211\316\277\333\340p\312\261\013\336?h\317&V\260\241\313\277\270\324^\261\310e\305? \340&\332\\\315\251\277F\267rd\005\321v\277\007M\277C\242\t\263\277\014Z\265]\2266\310\277\260I\027v\334\256\311\277X\213\035f\0271\322\277\034\022\372\343*\231~?/}L\035\307\207\321?\365\362z\025W\320\231?\267\270\345\272\3434\331\277T\302\200~\002q\303?G\330\346\225\363F\312?M\377h\261\2419\224\277\032iq|\034\366\320?\361\317\345\371!\022\200?\325\213Vu\222\003\315?\376\330\267\222\2075\221\277~\304\235B&\363\300? _L\225y\260\261\2772\274\320F\255z\224?\364\355\212\234\260\004\310\277\004%\260\235\334\376\324\277zd\224\333*J\313\277\2115\025+VB\277\277\311\200\342\026a\355\277\2775\367\325\210\"\245\302\277\023%kf\205\377\264?33X\027u^\260\277[\223L\221\010Z\226?^=Z\3620\317\305\277\322\362\372zW\377\272?\"o>\325C2\312?~Si\361\336\245\270?!\006~F\036D\234\277#\227\360\023\301\314\276?\203\3360,\366.\310?yv\313\\l\025\324\277d\244\335\357@\032\251?\035\314\027\226\027\312\267?\233\200\246\326\026M\310?\352p\004z\377\273\270?\313B\216\335+\031\322\277\237\324\223\254\005\354\300\277\217\020wJ\242\316\302?=X\177\241\226\376\261\277\177\242\264N\016/\274\277\322\003B9rj\276\277W\324\0072\224w\265?\030\304\330\322r\374\210?7U\306HR^\324?\016\227\r\301\214\372\302\277\310\307\331qy\207\300\277\214\220\3348$_\302?J\301\370&\247\210\310\277=\302\364?i!\300\277\177\361\305>\2716\277\277\213\360\322\213Q\001\257?\231\177\313x\2640\311\277\001H0Q\370e\222?\316nZ\373\313\037\270\277\351W\317\341\217\375\305?\226m\242\314\217\240\213\277\\\265I\220\246\335\243?|\244\033A\0169\304?\335\231\201w\240\002\304\277\007i\317\364(\316\243?\332v\220\2614\006\266\277x\375`\275\321\325\243\277\2017\355Lh<\320\277\027Wu~gq\316?\254\"\021\326r\261\263?\014\251\377D\300\323\322\277\253/HK]T\305\277\033Aa\373\3456\303\277\347,u\321I\342\273\277>\251\031\221\361\226\200?\273\335\253t\233\315\243?\257G4)\'V\300\277l\321y\312}\372\311?\365.]z\326\215\321\277\257@\014=D}\307\2773JO\337\033z\303?\366 \367\007\302y\177\277\0216\374c\360\373\306?S\375\243\231\267\025\244\277\232\355\205\213\236|\251?\273^\314u\034\237\262\277#\014p$\371\217\220\277\\\001M\377XK\276?\327:\262\241\217S\326?\236\300\"\031\314_\237?\034\334O\342\274W\276\277\261\2732i\200\016\306?\225\261\374\245\344\\\304\277X\250_\3716=\304\277f\rto\332I\300\277X\371(\277\007%\226\277\031\236o\271\335\367\277\277\027 \347\032J\277\263?\356\354-\235X\210\331\277a\262\240\200C\322\310\277\351\361!e;\301\300?\267\177\242\346\177\225\301?\345z\214\2171\311\311?\343l\010.\371\301\243?\252\335\201^4\003\306?pc\305\331\360\331\323\277\251\016\353\242\005\'\322?@%<0\276\205\211?\325\202o\263$\022\250?\353\2025\271X\336\260\277\004J\317\327Q\014\234\277{-T\333\311\006\310\277R\021\037\236v[\260?\312\261\321\226\303X\277\277\352V\344\003\331\315\301\277\211D\233\223\016\233\261?\337R\351\254\342D\244\277\262\025\274\006\312a\253\277\352\254ti\266N\263?\355\220\\\357\004\177\214\277.\374d\006O\242\271?\376\227=V\'\326\303?U7\330P\311o\274\277\022\003\272\253\035\240\214\277\177\256\215\347\330I\247\277\315\346\240/>\t\266\277\027Sx\277zs\267\277S\023l\373|\356\256?\304b\366\265\234\202\245?\242\307\331\034\232\277{?\021\205\323aI\331\226?\037\017qO\366\003\325?\t\351\340V\021\323\255\277\274\233)\244\360\004[?\213\360\371\211\037\314\220?%Y\341\255\366\336\307?7\310\016s\327j\246?\025\256\325\375\327\211\247?\035\352\356\007.\275\300\277\247\017\372\303\223\250\262?H\031Rx7\347\206?\275\3212\320\302 \261\277\336\230\242v-=\302\277|&\243H\332\347\242\277\206\3624\271=\023\246\277\037\376>\204\004\024\265\277\347#ZWJ\324\323\277\242*\346\245k,\262\277j\371\272\330\021\250\323\277\036\3546\244XS\226?[j\016\342\000n\316?T7I\026S\n\252\277\307\327\211\276\364\356\271?\307\253\006\266\256u\267\277uK\007juN\266\277\024\316-\001\231\263\316?\306\222q\327\220G\247\277\337\036R\3734\246\312?\036\275\344H\r>\266?\207\014\351=\210\332\256\277\273\272\220\313]|\277?\240\364jF\216\274\245\277a\017\365\235\017*\243\277B\\\010\236\323\221\232?\314\2436\362k\023\254\277\364cN\372\303\323\274\277#(a\244\303\314\310?\272t\206\014\376\311\320\277\322b\311m\265\201\247?~9\031\235\371A\271?\206\216\270\024\007\346\266\277Q\030\263\3316\003\262\277\351q\266\365\240L\311\277\3556\315tG\346\262?a\351R\361[\035\302?\304\337R{\020\"\314\277x\246C\333X\361\313\277\311\226\360\026\235\303\257?\363\\\344\370\255)\273?~2\'\350\026\254\300\277\214\257P\320IW\316\277(F\343\216Q\367\320\277\354`\024\305(\364\255?z\231yd.\275\310?\2322;;\202\265r\315\277>\254\317\314I\332\230?\325\244\311J\002\360\324\277<\224`\3367\010\252?\373\311\206\236\273w\226?\307[\214\202\010\205\301\277\034b\204,\034\320\243?\225\360\242^\252o\265?\010l:0f\346\260?\247\301\222\320\246=\245?" + } + } + } +} +node { + name: "layer_0_type_0/matrix/read" + op: "Identity" + input: "layer_0_type_0/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_0_type_0/matrix" + } + } + } +} +node { + name: "layer_0_type_0/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "!\262\350\344\'Q\366\277\226\003\256\\\222n\242?\257@\0023\"\017\340\277\277\214\010\272\270\215\340?\214\017.\257\3452\324?w\304\343\204\365\350\316\277b\304\277)@\356\354\315\320[?\351\325\007\260\351\033\305\277\320\002\200}pv\267\277<\223\010\266|\226\266\277\343\242\263o\336\326\314?\332\014\022\3378\275\313?\256c\007\255w\036\323?T\254s\260c\307\266?\226\220b+&\206\256\277\230\320s\006\300\021\334?.\021\262\327\352\350\326?`l\255\312E9\335?\326!\203b\314\013\205\277\023\227{\030c@\273\277F\217gD\334\334\325\277\271\001\250NCQ\252?#a\254*y\260\270\277;=\214P>W\321?\227\035<\027Aw\321\277\276R>\243\253\235\303\277l,|\016b4\267?\353\245\306\323\246}\325\277\363N\343\277 \361\307\277I\351\314G\226\210\201\277\345X\010\274\247\343\310\277\223\006\312\3711C\304?\203\333}\360G\367\325?-\354>HD\316\305?W\260\233\237\254\241\317?\205\254P\374\233\240\300\277\312G\251\263\3247\274?6l\376E\033g\302\277\307\343.z]\030\321\2779\221O\362\357\237\315\277\2242\034\335\366\252\235\277d\375\270\233\301\013\241?T\275`\204\350q\324?u\226CR:_\267?\334(c\327\037\t\260?\354O<\310v\227\306?\273/\004t\276\337\315?r\333J\314\341\214\231?e\032\201\315\274\016\266?\320\033\033\006yK\242\277\007<\007<\366\362\330\277l\320\231\007\336\312\302\277\320\375\352\370\373^\321\277\372\342S\003d!\202\362\277\276\221\372\220\265\302\377\277\237FAOs\204\354\277G\365\224\373\007\206\365?\3362\250ZA\321\315\277\'\224V\371s\333\264?" + } + } + } +} +node { + name: "layer_1_type_0/bias/read" + op: "Identity" + input: "layer_1_type_0/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_1_type_0/bias" + } + } + } +} +node { + name: "layer_1_type_0/MatMul" + op: "MatMul" + input: "layer_0_type_0/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "layer_1_type_0/add" + op: "AddV2" + input: "layer_1_type_0/MatMul" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_1_type_0/idt" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "\026\214t\206\304\346\300?\035\024\304\337\006\277\300?\023\335\362~1\3234\277`exI\265\005\256?\214u\245\207\233|\310?\366+\271\245]\363\251?d\302\350;\261\257\305?\302ZP\347z\"\277?\340\316c\342c\332s?\360\004\036X\036\001\230?" + } + } + } +} +node { + name: "layer_1_type_0/idt/read" + op: "Identity" + input: "layer_1_type_0/idt" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_1_type_0/idt" + } + } + } +} +node { + name: "layer_1_type_0/Tanh" + op: "Tanh" + input: "layer_1_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_1_type_0/Reshape/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "layer_1_type_0/Reshape" + op: "Reshape" + input: "layer_1_type_0/Tanh" + input: "layer_1_type_0/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_1_type_0/mul" + op: "Mul" + input: "layer_1_type_0/Reshape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "add_4" + op: "AddV2" + input: "layer_0_type_0/Reshape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_2_type_0/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "|\001\n\225\031n\276?\317I2,\314\223\300?-YAi\245\315\304\277k\266\350\nN\352\256?]\253m[\363\332\302?u\247a\017qn\335\277\357\213;$\207\337\317?\270\240\344\355\236\201\265\277\272b\247\022\020\016\223?\030=\021\313\347\033\322?\205\274?\376\363\314\330?\020\235\010\030\343\004\264?\2354\205\306f\306\327?\255\n\365\036.\275\336?\225\362a\021\305e\235\277\371dVc\346R\270?\267C\013\371\352\033\312\277\346oY\360\006\t\265\277\270>\373\241\024\217\333?_W\022\201\312f\326\277t\3608L\273b\306?\326:\'S`\350\266\277l\377\3119Z\350\255\277\024\376)\334\003\000\247?\016q]{\362L\322?\217}\336c\325\330\321?*\240\000\213E6\331\277\"\177J\305<+\223\277,:\360t.\262\317?u\214\003\354s0\322?\340\277Z\266^u\301\277\324\265\352\277\345\247\331?\204\022l\360\027\024\313\277\320\010\"c\313\304\320\277*\207\304\235\006\352\305\277\250\377@3\325\215\213\277\263\010\014\232\302\322\267\277\232\344\264\301\204\001\337\277q$\216\240m\351\264?\356d\216\325\032\303\306\277\362N\363\204\272\326\271\277w\302\304(6\307\327\277\347O@\022\014\r\254\277\201\351\201G\361\252\231?@D\r\223IT\305?-|\020\t|m\220?K\242\352\265\366\275\321\277\020\177\276k]#\245\277]\366\333\215B\372\304\2772\322\3268\\\335\225\277{q\330+\2574\315?\374\334C\036\347+\304?\246AL\301\244]\317\277\206\347.\323M\201\330\277i\201\026\247~V\303?\345\320\276\232\363W\254?l\026\272|5^\305?\275\211&[\"\377\306\277\'\350\027\002|\344\247?\354\027\241\245;\323?\356`8/L\240\300?\242Q\203\3349\371\315\277^\317T\231\0303\246?\0277\361\225\270[\267?v\307\207\247s\311\310?\233\325\242|\211\245\303?\206+\360\356\016+\250\277\216\220\264C\315\"\324?\320\023\2655z}\276?z\252\302>e\211\342\277k\360t\310\235\367\317\277U3\277\371\231\373\224?\014\346o\023\330\210\334?\234\3437\320\330\302\265?\"\203cRET\276\277C\254\013\247\237\342\305?\345\372\214\2568\232\336\277G7\242P\023\271\324?\244\350\016_\217j\235\277McU~\220w\304\2772\177\037cM\371\262\277\226}r\021\220W\307\2779;\2738\3606\272?\'r\245\017*j\305\277\307Z9F\275\010\310?t\352\316\272\277_\307\277A:Z[&\337\303\277\377\250\226\325%\354\321\277\277\007\013\235\0361\334\277\241\214\266Y-\266\273?\027xP\372|(\275\277\226\3342yS\327\334\277n\2057\370\377\030\306?\367\324\356\023\243\302\214?" + } + } + } +} +node { + name: "layer_2_type_0/matrix/read" + op: "Identity" + input: "layer_2_type_0/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_2_type_0/matrix" + } + } + } +} +node { + name: "layer_2_type_0/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "\r+\021\206\257\000\370\277\021\244\353Tc\370\354\277\r\303\366G[P\305?\337\352H\372\0245\304\277]zZ\223t\300\364\277\033{\375\2227\347\334?\351\306G\321\023\375\321?r\372\320\273j\202\360?&\027E\243ed\377?\360\235\240J\007\233\350\277" + } + } + } +} +node { + name: "layer_2_type_0/bias/read" + op: "Identity" + input: "layer_2_type_0/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_2_type_0/bias" + } + } + } +} +node { + name: "layer_2_type_0/MatMul" + op: "MatMul" + input: "add_4" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "layer_2_type_0/add" + op: "AddV2" + input: "layer_2_type_0/MatMul" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_2_type_0/idt" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "\352A\030\312BF\305?\034\344l\002n/\300?X~\302{U\342\256\277\177\266\353\240A\306\220\2778\000\021u{L\310?\"\3339\367\322\017\276?\013{\033a\337\333\250?q\020rFT\007\274?\357\177<\330\362\357\310?\337\326\245\255\r=\245?" + } + } + } +} +node { + name: "layer_2_type_0/idt/read" + op: "Identity" + input: "layer_2_type_0/idt" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_2_type_0/idt" + } + } + } +} +node { + name: "layer_2_type_0/Tanh" + op: "Tanh" + input: "layer_2_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_2_type_0/Reshape/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "layer_2_type_0/Reshape" + op: "Reshape" + input: "layer_2_type_0/Tanh" + input: "layer_2_type_0/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_2_type_0/mul" + op: "Mul" + input: "layer_2_type_0/Reshape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "add_5" + op: "AddV2" + input: "add_4" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "final_layer_type_0/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\277\254\223\307\014>\331?e\373)\245\236\010U?\222\220\032mEq\270?M\333\031bf\370\337?\364\020\343X\204\317\266\277\025\001\261\306(\356\321?)\210\215S)\323\340?%N1)\254\333\320\277\200\025\352\005{\223\321\277ia\230\316\272\310\323\277P\033p?wu\320?$\032\214\034\206\025\311?\033\336?l\200\317\263\277C\026B\374U1\334\277\226\036]\356\232\340\252?<\374\271p3\021\233\277\255\201q\364\231\252\335?7\207^\026\037\267\264\277Z\274Y\225\331-\310?\264\331\264?~&\241?N\2775_{\243\313?\372fUu\010n\343?\013\277\370\353\373\354\312?\315\366{\222J\356\324?\332\316\211\222\360\211\325\277\256R\360Z\347\306\270?6\030\342\256\301S\322?\"\037z\301:4\263?\355\356\317\262h\n\203?\315\030k\210s\366\314\2778]\363\340\372\335\324\277&\370n\304Q\033\312\277I\227dYP\t\315?1Z\2508\032\307\304?\362\2335p\310\266v?\276\237\356\234[\021\325\277\257\264&\334\355\266\313\277(\300H\360C\347j\277\316\343i2\303\034\306?a\034\303Z\262\034\302?I/f+\260\226\335\277\355\276\304\000\216.\346\277\264\271\344\270\023.\301?\303\277!\342\032\346\263\2778C9\'*\343f?ok\356\025M^\305\277NhA\207l\340\240\277\001\311u\2554I\326\277\273\254\207\335\'X\322?J\367\305\365\200\006\267\277`\006\310\267_\246\264?\215\326-\370U\203\310?\277\206\261\217y\303\306?\215J\217\303o\306\307?\226b\305\376\203y\317\277i\330\320\271}\"\274?\032\013\220\266\013\266\257?\343\241j\225<\004f?v\267wO\222\346\325\277\324\212\332\323M\007\256?d\000\343\n\224\306\300?u\t>0\261\375\276?\307\023\307\345\340&\301?7\353\324U\257D\307?l\265\210#&~\335\277Y\336\333\205\324\244\256?\347P4\226\016\257\303\277\\os\035\375a\333\277\206\034\231 \014j\273?\256\234\332D\276\355\303\277GD\354\303u\353\317\277v\366\235)\333\200\301?\3705J\314\376\355\324\277\301R\323\273\306\034\336?\232e-\010\317\037\267?\256\262\034!e{\263?\341\360\324\331I\356\331\277$\244DcbV\325?m\350.\237\325f\324\277\t<1X\251W\305?\227\277\351\214\n\023\217\277\177Lm\236\340r\260?\244\227\013A\206\036\240?\250\023\247\277\206h\313\277\232\220\207~\0306\346?\2154\'\263u+\337\277\356Tp\317p}\321\277:\246F\000\351\223\325\277\252\232y\330;\310\324\2778\rf\247\234\036\235?\360,\024Z\312\305\323?@\006\375D>\005\240?7\252\351Ju\363\276?\222S\202Q{1\336?Sg\342\234d\024\315?\346-\033\027\375C\314\277ff\237\243\337\177\336\277\027\266\2368\331\035\302?l\336r\353\251\240\301?<\305\\\204\025\224\254?" + } + } + } +} +node { + name: "final_layer_type_0/matrix/read" + op: "Identity" + input: "final_layer_type_0/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@final_layer_type_0/matrix" + } + } + } +} +node { + name: "final_layer_type_0/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "[\2564\222Xg\302?=o\311\325\276\006\347?\226z\210\265\214\351\367?\342J\262\027\2407\325?\207\361X\006\271\276\371\277d\330\274Y\314m\361?\177\305\204)#\240\367?\374\300/_R\030\340\277\262\250\347\266V\225\311\277>9\313\255\313\334\311\277" + } + } + } +} +node { + name: "final_layer_type_0/bias/read" + op: "Identity" + input: "final_layer_type_0/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@final_layer_type_0/bias" + } + } + } +} +node { + name: "final_layer_type_0/MatMul" + op: "MatMul" + input: "add_5" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "final_layer_type_0/add" + op: "AddV2" + input: "final_layer_type_0/MatMul" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Shape_6" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_25/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_25/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_25/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_25" + op: "StridedSlice" + input: "Shape_6" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_26/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_26/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_26/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_26" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_15" + op: "Mul" + input: "strided_slice_25" + input: "strided_slice_26" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_17/shape/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "Reshape_17/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 10 + } + } + } +} +node { + name: "Reshape_17/shape" + op: "Pack" + input: "mul_15" + input: "Reshape_17/shape/1" + input: "Reshape_17/shape/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_17" + op: "Reshape" + input: "final_layer_type_0/add" + input: "Reshape_17/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "MatMul" + op: "BatchMatMulV2" + input: "Reshape_17" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "Shape_7" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_27/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_27/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_27/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_27" + op: "StridedSlice" + input: "Shape_7" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_28/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_28/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_28/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_28" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Reshape_18/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "Reshape_18/shape" + op: "Pack" + input: "strided_slice_27" + input: "strided_slice_28" + input: "Reshape_18/shape/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_18" + op: "Reshape" + input: "MatMul" + input: "Reshape_18/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_21/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_21" + op: "Reshape" + input: "Reshape_18" + input: "Reshape_21/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_20/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_20" + op: "Mul" + input: "add" + input: "mul_20/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "o_dipole/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "o_dipole/shape" + op: "Pack" + input: "o_dipole/shape/0" + input: "mul_20" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "o_dipole" + op: "Reshape" + input: "Reshape_21" + input: "o_dipole/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_22/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_22/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "Reshape_22/shape" + op: "Pack" + input: "Reshape_22/shape/0" + input: "add" + input: "Reshape_22/shape/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_22" + op: "Reshape" + input: "o_dipole" + input: "Reshape_22/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Sum/reduction_indices" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "Sum" + op: "Sum" + input: "Reshape_22" + input: "Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "o_global_dipole/shape" + op: "Const" + 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: "o_global_dipole" + op: "Reshape" + input: "Sum" + input: "o_global_dipole/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "split/split_dim" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "split" + op: "Split" + input: "split/split_dim" + input: "Reshape_22" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "num_split" + value { + i: 3 + } + } +} +node { + name: "gradients/Shape" + op: "Shape" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients/grad_ys_0" + op: "Fill" + input: "gradients/Shape" + input: "gradients/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/zeros_like" + op: "ZerosLike" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/zeros_like_1" + op: "ZerosLike" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/split_grad/concat" + op: "ConcatV2" + input: "gradients/grad_ys_0" + input: "gradients/zeros_like" + input: "gradients/zeros_like_1" + input: "split/split_dim" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_22_grad/Shape" + op: "Shape" + input: "o_dipole" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients/split_grad/concat" + input: "gradients/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/o_dipole_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/o_dipole_grad/Reshape" + op: "Reshape" + input: "gradients/Reshape_22_grad/Reshape" + input: "gradients/o_dipole_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_21_grad/Shape" + op: "Shape" + input: "Reshape_18" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients/o_dipole_grad/Reshape" + input: "gradients/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients/Reshape_21_grad/Reshape" + input: "gradients/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients/Reshape_18_grad/Reshape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_17" + input: "gradients/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients/MatMul_grad/Shape" + input: "gradients/MatMul_grad/strided_slice/stack" + input: "gradients/MatMul_grad/strided_slice/stack_1" + input: "gradients/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/MatMul_grad/Shape_1" + input: "gradients/MatMul_grad/strided_slice_1/stack" + input: "gradients/MatMul_grad/strided_slice_1/stack_1" + input: "gradients/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/MatMul_grad/strided_slice" + input: "gradients/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/Sum" + op: "Sum" + input: "gradients/MatMul_grad/MatMul" + input: "gradients/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients/MatMul_grad/Sum" + input: "gradients/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients/MatMul_grad/MatMul_1" + input: "gradients/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients/MatMul_grad/Sum_1" + input: "gradients/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients/MatMul_grad/Reshape" + input: "gradients/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients/MatMul_grad/Reshape_1" + input: "gradients/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/final_layer_type_0/add_grad/Shape" + input: "gradients/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/Reshape_17_grad/Reshape" + input: "gradients/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/final_layer_type_0/add_grad/Sum" + input: "gradients/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_3_grad/stack" + op: "Pack" + input: "gradients/Slice_3_grad/Rank" + input: "gradients/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/sub" + op: "Sub" + input: "gradients/Slice_3_grad/Shape_1" + input: "gradients/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/Slice_3_grad/sub_1" + input: "gradients/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients/Slice_3_grad/Reshape" + input: "gradients/Slice_3_grad/Reshape_1" + input: "gradients/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 + } + } +} +node { + name: "gradients/Slice_3_grad/Pad" + op: "Pad" + input: "gradients/Reshape_16_grad/Reshape" + input: "gradients/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients/Slice_3_grad/Pad" + input: "gradients/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_5_grad/Shape" + op: "Shape" + input: "add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_5_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/add_5_grad/Shape" + input: "gradients/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_5_grad/Sum" + op: "Sum" + input: "gradients/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_5_grad/Reshape" + op: "Reshape" + input: "gradients/add_5_grad/Sum" + input: "gradients/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_5_grad/Sum_1" + op: "Sum" + input: "gradients/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients/add_5_grad/Sum_1" + input: "gradients/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_2_type_0/mul_grad/Shape" + input: "gradients/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients/add_5_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients/layer_2_type_0/mul_grad/Mul" + input: "gradients/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients/layer_2_type_0/mul_grad/Sum" + input: "gradients/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/concat_1_grad/mod" + input: "gradients/concat_1_grad/ShapeN" + input: "gradients/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/concat_1_grad/Slice" + op: "Slice" + input: "gradients/Reshape_14_grad/Reshape" + input: "gradients/concat_1_grad/ConcatOffset" + input: "gradients/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients/Reshape_14_grad/Reshape" + input: "gradients/concat_1_grad/ConcatOffset:1" + input: "gradients/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/layer_2_type_0/mul_grad/Reshape" + input: "gradients/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients/concat_1_grad/Slice" + input: "gradients/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients/concat_1_grad/Slice_1" + input: "gradients/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients/Reshape_8_grad/Reshape" + input: "gradients/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients/Reshape_12_grad/Reshape" + input: "gradients/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_2_type_0/add_grad/Shape" + input: "gradients/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/layer_2_type_0/add_grad/Sum" + input: "gradients/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_5_grad/Rank" + input: "gradients/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_5_grad/sub_1" + input: "gradients/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_5_grad/Reshape" + input: "gradients/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients/filter_type_0/transpose_grad/transpose" + input: "gradients/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_5_grad/Rank" + input: "gradients/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_5_grad/sub_1" + input: "gradients/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_5_grad/Reshape" + input: "gradients/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients/filter_type_1/transpose_grad/transpose" + input: "gradients/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/AddN" + op: "AddN" + input: "gradients/add_5_grad/Reshape" + input: "gradients/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients/add_4_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_4_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/add_4_grad/Shape" + input: "gradients/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_4_grad/Sum" + op: "Sum" + input: "gradients/AddN" + input: "gradients/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_4_grad/Reshape" + op: "Reshape" + input: "gradients/add_4_grad/Sum" + input: "gradients/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_4_grad/Sum_1" + op: "Sum" + input: "gradients/AddN" + input: "gradients/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/add_4_grad/Sum_1" + input: "gradients/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_1_type_0/mul_grad/Shape" + input: "gradients/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients/add_4_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients/layer_1_type_0/mul_grad/Mul" + input: "gradients/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients/layer_1_type_0/mul_grad/Sum" + input: "gradients/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/layer_1_type_0/mul_grad/Reshape" + input: "gradients/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_1_type_0/add_grad/Shape" + input: "gradients/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/layer_1_type_0/add_grad/Sum" + input: "gradients/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/AddN_1" + op: "AddN" + input: "gradients/add_4_grad/Reshape" + input: "gradients/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_1" + input: "gradients/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_0_type_0/add_grad/Shape" + input: "gradients/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/layer_0_type_0/add_grad/Sum" + input: "gradients/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_2_grad/stack" + op: "Pack" + input: "gradients/Slice_2_grad/Rank" + input: "gradients/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/sub" + op: "Sub" + input: "gradients/Slice_2_grad/Shape_1" + input: "gradients/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/Slice_2_grad/sub_1" + input: "gradients/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients/Slice_2_grad/Reshape" + input: "gradients/Slice_2_grad/Reshape_1" + input: "gradients/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 + } + } +} +node { + name: "gradients/Slice_2_grad/Pad" + op: "Pad" + input: "gradients/Reshape_15_grad/Reshape" + input: "gradients/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients/Slice_2_grad/Pad" + input: "gradients/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/concat_grad/mod" + input: "gradients/concat_grad/ShapeN" + input: "gradients/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/concat_grad/Slice" + op: "Slice" + input: "gradients/Reshape_13_grad/Reshape" + input: "gradients/concat_grad/ConcatOffset" + input: "gradients/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/concat_grad/Slice_1" + op: "Slice" + input: "gradients/Reshape_13_grad/Reshape" + input: "gradients/concat_grad/ConcatOffset:1" + input: "gradients/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients/concat_grad/Slice" + input: "gradients/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients/concat_grad/Slice_1" + input: "gradients/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients/Reshape_7_grad/Reshape" + input: "gradients/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients/Reshape_11_grad/Reshape" + input: "gradients/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_8_grad/Shape" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_8_grad/Sum" + input: "gradients/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_8_grad/Shape" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_8_grad/Sum" + input: "gradients/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_4_grad/Rank" + input: "gradients/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_4_grad/sub_1" + input: "gradients/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_4_grad/Reshape" + input: "gradients/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_4_grad/Rank" + input: "gradients/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_4_grad/sub_1" + input: "gradients/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_4_grad/Reshape" + input: "gradients/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_2" + op: "AddN" + input: "gradients/filter_type_0/Slice_5_grad/Pad" + input: "gradients/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/mul_grad/Shape" + input: "gradients/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients/AddN_2" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/mul_grad/Mul" + input: "gradients/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/mul_grad/Sum" + input: "gradients/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_3" + op: "AddN" + input: "gradients/filter_type_1/Slice_5_grad/Pad" + input: "gradients/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/mul_grad/Shape" + input: "gradients/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients/AddN_3" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/mul_grad/Mul" + input: "gradients/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/mul_grad/Sum" + input: "gradients/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_10_grad/Shape" + input: "gradients/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/mul_grad/Reshape" + input: "gradients/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_10_grad/Sum" + input: "gradients/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/mul_grad/Reshape" + input: "gradients/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_10_grad/Sum_1" + input: "gradients/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_10_grad/Shape" + input: "gradients/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/mul_grad/Reshape" + input: "gradients/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_10_grad/Sum" + input: "gradients/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/mul_grad/Reshape" + input: "gradients/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_10_grad/Sum_1" + input: "gradients/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_3_grad/Shape" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_3_grad/Sum" + input: "gradients/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_7_grad/Shape" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_7_grad/Sum" + input: "gradients/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_3_grad/Shape" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_3_grad/Sum" + input: "gradients/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_7_grad/Shape" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_7_grad/Sum" + input: "gradients/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/add_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_4_grad/Shape" + input: "gradients/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_4_grad/Sum" + input: "gradients/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_4_grad/Sum_1" + input: "gradients/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_9_grad/Shape" + input: "gradients/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_9_grad/Sum" + input: "gradients/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_9_grad/Sum_1" + input: "gradients/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/add_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_4_grad/Shape" + input: "gradients/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_4_grad/Sum" + input: "gradients/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_4_grad/Sum_1" + input: "gradients/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_9_grad/Shape" + input: "gradients/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_9_grad/Sum" + input: "gradients/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_9_grad/Sum_1" + input: "gradients/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_4_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_9_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_4_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_9_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_3_grad/Shape" + input: "gradients/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_3_grad/Sum" + input: "gradients/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_8_grad/Shape" + input: "gradients/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_8_grad/Sum" + input: "gradients/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_3_grad/Shape" + input: "gradients/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_3_grad/Sum" + input: "gradients/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_8_grad/Shape" + input: "gradients/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_8_grad/Sum" + input: "gradients/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/AddN_4" + op: "AddN" + input: "gradients/filter_type_0/add_4_grad/Reshape" + input: "gradients/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_2_grad/Shape" + input: "gradients/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients/AddN_4" + input: "gradients/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_2_grad/Sum" + input: "gradients/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_4" + input: "gradients/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_2_grad/Sum_1" + input: "gradients/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_5" + op: "AddN" + input: "gradients/filter_type_0/add_9_grad/Reshape" + input: "gradients/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_7_grad/Shape" + input: "gradients/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients/AddN_5" + input: "gradients/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_7_grad/Sum" + input: "gradients/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_5" + input: "gradients/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_7_grad/Sum_1" + input: "gradients/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_6" + op: "AddN" + input: "gradients/filter_type_1/add_4_grad/Reshape" + input: "gradients/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_2_grad/Shape" + input: "gradients/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients/AddN_6" + input: "gradients/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_2_grad/Sum" + input: "gradients/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_6" + input: "gradients/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_2_grad/Sum_1" + input: "gradients/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_7" + op: "AddN" + input: "gradients/filter_type_1/add_9_grad/Reshape" + input: "gradients/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_7_grad/Shape" + input: "gradients/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients/AddN_7" + input: "gradients/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_7_grad/Sum" + input: "gradients/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_7" + input: "gradients/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_7_grad/Sum_1" + input: "gradients/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/concat_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat/axis" + input: "gradients/filter_type_0/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/filter_type_0/concat_grad/mod" + input: "gradients/filter_type_0/concat_grad/ShapeN" + input: "gradients/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/filter_type_0/concat_grad/Slice" + op: "Slice" + input: "gradients/filter_type_0/add_2_grad/Reshape" + input: "gradients/filter_type_0/concat_grad/ConcatOffset" + input: "gradients/filter_type_0/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/concat_grad/Slice_1" + op: "Slice" + input: "gradients/filter_type_0/add_2_grad/Reshape" + input: "gradients/filter_type_0/concat_grad/ConcatOffset:1" + input: "gradients/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_2_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_1/axis" + input: "gradients/filter_type_0/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/filter_type_0/concat_1_grad/mod" + input: "gradients/filter_type_0/concat_1_grad/ShapeN" + input: "gradients/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/filter_type_0/concat_1_grad/Slice" + op: "Slice" + input: "gradients/filter_type_0/add_7_grad/Reshape" + input: "gradients/filter_type_0/concat_1_grad/ConcatOffset" + input: "gradients/filter_type_0/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients/filter_type_0/add_7_grad/Reshape" + input: "gradients/filter_type_0/concat_1_grad/ConcatOffset:1" + input: "gradients/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_7_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/concat_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat/axis" + input: "gradients/filter_type_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/filter_type_1/concat_grad/mod" + input: "gradients/filter_type_1/concat_grad/ShapeN" + input: "gradients/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/filter_type_1/concat_grad/Slice" + op: "Slice" + input: "gradients/filter_type_1/add_2_grad/Reshape" + input: "gradients/filter_type_1/concat_grad/ConcatOffset" + input: "gradients/filter_type_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients/filter_type_1/add_2_grad/Reshape" + input: "gradients/filter_type_1/concat_grad/ConcatOffset:1" + input: "gradients/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_2_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_1/axis" + input: "gradients/filter_type_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/filter_type_1/concat_1_grad/mod" + input: "gradients/filter_type_1/concat_1_grad/ShapeN" + input: "gradients/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/filter_type_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients/filter_type_1/add_7_grad/Reshape" + input: "gradients/filter_type_1/concat_1_grad/ConcatOffset" + input: "gradients/filter_type_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients/filter_type_1/add_7_grad/Reshape" + input: "gradients/filter_type_1/concat_1_grad/ConcatOffset:1" + input: "gradients/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_7_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_1_grad/Shape" + input: "gradients/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_1_grad/Sum" + input: "gradients/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_6_grad/Shape" + input: "gradients/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_6_grad/Sum" + input: "gradients/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_1_grad/Shape" + input: "gradients/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_1_grad/Sum" + input: "gradients/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_6_grad/Shape" + input: "gradients/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_6_grad/Sum" + input: "gradients/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/AddN_8" + op: "AddN" + input: "gradients/filter_type_0/concat_grad/Slice" + input: "gradients/filter_type_0/concat_grad/Slice_1" + input: "gradients/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/concat_grad/Slice" + } + } + } +} +node { + name: "gradients/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_8" + input: "gradients/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_9" + op: "AddN" + input: "gradients/filter_type_0/concat_1_grad/Slice" + input: "gradients/filter_type_0/concat_1_grad/Slice_1" + input: "gradients/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_9" + input: "gradients/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_10" + op: "AddN" + input: "gradients/filter_type_1/concat_grad/Slice" + input: "gradients/filter_type_1/concat_grad/Slice_1" + input: "gradients/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/concat_grad/Slice" + } + } + } +} +node { + name: "gradients/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_10" + input: "gradients/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_11" + op: "AddN" + input: "gradients/filter_type_1/concat_1_grad/Slice" + input: "gradients/filter_type_1/concat_1_grad/Slice_1" + input: "gradients/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_11" + input: "gradients/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_grad/Shape" + input: "gradients/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_grad/Sum" + input: "gradients/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_5_grad/Shape" + input: "gradients/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_5_grad/Sum" + input: "gradients/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_grad/Shape" + input: "gradients/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_grad/Sum" + input: "gradients/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_5_grad/Shape" + input: "gradients/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_5_grad/Sum" + input: "gradients/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_grad/MatMul" + input: "gradients/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_grad/MatMul" + input: "gradients/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_1_grad/Rank" + input: "gradients/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_1_grad/sub_1" + input: "gradients/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_1_grad/Reshape" + input: "gradients/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_3_grad/Rank" + input: "gradients/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_3_grad/sub_1" + input: "gradients/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_3_grad/Reshape" + input: "gradients/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_1_grad/Rank" + input: "gradients/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_1_grad/sub_1" + input: "gradients/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_1_grad/Reshape" + input: "gradients/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_3_grad/Rank" + input: "gradients/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_3_grad/sub_1" + input: "gradients/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_3_grad/Reshape" + input: "gradients/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/Slice_1_grad/Pad" + input: "gradients/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/Slice_3_grad/Pad" + input: "gradients/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/Slice_1_grad/Pad" + input: "gradients/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/Slice_3_grad/Pad" + input: "gradients/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_12" + op: "AddN" + input: "gradients/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_grad/Rank" + input: "gradients/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_grad/Shape_1" + input: "gradients/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_grad/sub_1" + input: "gradients/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_grad/Reshape" + input: "gradients/filter_type_0/Slice_grad/Reshape_1" + input: "gradients/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients/AddN_12" + input: "gradients/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_13" + op: "AddN" + input: "gradients/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_2_grad/Rank" + input: "gradients/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_2_grad/sub_1" + input: "gradients/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_2_grad/Reshape" + input: "gradients/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients/AddN_13" + input: "gradients/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_14" + op: "AddN" + input: "gradients/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_grad/Rank" + input: "gradients/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_grad/Shape_1" + input: "gradients/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_grad/sub_1" + input: "gradients/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_grad/Reshape" + input: "gradients/filter_type_1/Slice_grad/Reshape_1" + input: "gradients/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients/AddN_14" + input: "gradients/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_15" + op: "AddN" + input: "gradients/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_2_grad/Rank" + input: "gradients/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_2_grad/sub_1" + input: "gradients/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_2_grad/Reshape" + input: "gradients/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients/AddN_15" + input: "gradients/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_16" + op: "AddN" + input: "gradients/filter_type_0/Slice_grad/Pad" + input: "gradients/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_16" + input: "gradients/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_17" + op: "AddN" + input: "gradients/filter_type_1/Slice_grad/Pad" + input: "gradients/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_17" + input: "gradients/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_grad/stack" + op: "Pack" + input: "gradients/Slice_grad/Rank" + input: "gradients/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/sub" + op: "Sub" + input: "gradients/Slice_grad/Shape_1" + input: "gradients/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/sub_1" + op: "Sub" + input: "gradients/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients/Slice_grad/sub_1" + input: "gradients/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_grad/concat" + op: "ConcatV2" + input: "gradients/Slice_grad/Reshape" + input: "gradients/Slice_grad/Reshape_1" + input: "gradients/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/Pad" + op: "Pad" + input: "gradients/Reshape_5_grad/Reshape" + input: "gradients/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_1_grad/stack" + op: "Pack" + input: "gradients/Slice_1_grad/Rank" + input: "gradients/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/sub" + op: "Sub" + input: "gradients/Slice_1_grad/Shape_1" + input: "gradients/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients/Slice_1_grad/sub_1" + input: "gradients/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients/Slice_1_grad/Reshape" + input: "gradients/Slice_1_grad/Reshape_1" + input: "gradients/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 + } + } +} +node { + name: "gradients/Slice_1_grad/Pad" + op: "Pad" + input: "gradients/Reshape_9_grad/Reshape" + input: "gradients/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_18" + op: "AddN" + input: "gradients/Slice_grad/Pad" + input: "gradients/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_18" + input: "gradients/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_32/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_32/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_32/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_32" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_32/stack" + input: "strided_slice_32/stack_1" + input: "strided_slice_32/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_21/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_21" + op: "Mul" + input: "strided_slice_32" + input: "mul_21/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_23/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_23/shape" + op: "Pack" + input: "Reshape_23/shape/0" + input: "mul_21" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_23" + op: "Reshape" + input: "gradients/Reshape_4_grad/Reshape" + input: "Reshape_23/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA" + op: "ProdForceSeA" + input: "Reshape_23" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA" + op: "ProdVirialSeA" + input: "Reshape_23" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_33/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_33/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_33/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_33" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_33/stack" + input: "strided_slice_33/stack_1" + input: "strided_slice_33/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_22/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_22" + op: "Mul" + input: "mul_22/x" + input: "strided_slice_33" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_24/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_24/shape" + op: "Pack" + input: "Reshape_24/shape/0" + input: "mul_22" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_24" + op: "Reshape" + input: "ProdForceSeA" + input: "Reshape_24/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_25/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_25" + op: "Reshape" + input: "ProdVirialSeA" + input: "Reshape_25/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_34/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_34/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_34/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_34" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_34/stack" + input: "strided_slice_34/stack_1" + input: "strided_slice_34/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_23/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_23" + op: "Mul" + input: "mul_23/x" + input: "strided_slice_34" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_26/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_26/shape" + op: "Pack" + input: "Reshape_26/shape/0" + input: "mul_23" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_26" + op: "Reshape" + input: "ProdVirialSeA:1" + input: "Reshape_26/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Shape" + op: "Shape" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients_1/grad_ys_0" + op: "Fill" + input: "gradients_1/Shape" + input: "gradients_1/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/zeros_like" + op: "ZerosLike" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/zeros_like_1" + op: "ZerosLike" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/split_grad/concat" + op: "ConcatV2" + input: "gradients_1/zeros_like" + input: "gradients_1/grad_ys_0" + input: "gradients_1/zeros_like_1" + input: "split/split_dim" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_22_grad/Shape" + op: "Shape" + input: "o_dipole" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients_1/split_grad/concat" + input: "gradients_1/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/o_dipole_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/o_dipole_grad/Reshape" + op: "Reshape" + input: "gradients_1/Reshape_22_grad/Reshape" + input: "gradients_1/o_dipole_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_21_grad/Shape" + op: "Shape" + input: "Reshape_18" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients_1/o_dipole_grad/Reshape" + input: "gradients_1/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients_1/Reshape_21_grad/Reshape" + input: "gradients_1/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients_1/Reshape_18_grad/Reshape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_17" + input: "gradients_1/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/MatMul_grad/Shape" + input: "gradients_1/MatMul_grad/strided_slice/stack" + input: "gradients_1/MatMul_grad/strided_slice/stack_1" + input: "gradients_1/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/MatMul_grad/Shape_1" + input: "gradients_1/MatMul_grad/strided_slice_1/stack" + input: "gradients_1/MatMul_grad/strided_slice_1/stack_1" + input: "gradients_1/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/MatMul_grad/strided_slice" + input: "gradients_1/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/Sum" + op: "Sum" + input: "gradients_1/MatMul_grad/MatMul" + input: "gradients_1/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients_1/MatMul_grad/Sum" + input: "gradients_1/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients_1/MatMul_grad/MatMul_1" + input: "gradients_1/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/MatMul_grad/Sum_1" + input: "gradients_1/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients_1/MatMul_grad/Reshape" + input: "gradients_1/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients_1/MatMul_grad/Reshape_1" + input: "gradients_1/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/final_layer_type_0/add_grad/Shape" + input: "gradients_1/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/Reshape_17_grad/Reshape" + input: "gradients_1/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/final_layer_type_0/add_grad/Sum" + input: "gradients_1/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_1/Slice_3_grad/Rank" + input: "gradients_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_1/Slice_3_grad/Shape_1" + input: "gradients_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_1/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/Slice_3_grad/sub_1" + input: "gradients_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_1/Slice_3_grad/Reshape" + input: "gradients_1/Slice_3_grad/Reshape_1" + input: "gradients_1/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 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_1/Reshape_16_grad/Reshape" + input: "gradients_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_1/Slice_3_grad/Pad" + input: "gradients_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_5_grad/Shape" + op: "Shape" + input: "add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_5_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/add_5_grad/Shape" + input: "gradients_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_1/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/add_5_grad/Sum" + input: "gradients_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_5_grad/Sum_1" + op: "Sum" + input: "gradients_1/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_1/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/add_5_grad/Sum_1" + input: "gradients_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_2_type_0/mul_grad/Shape" + input: "gradients_1/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_1/add_5_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_1/layer_2_type_0/mul_grad/Mul" + input: "gradients_1/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_2_type_0/mul_grad/Sum" + input: "gradients_1/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/concat_1_grad/mod" + input: "gradients_1/concat_1_grad/ShapeN" + input: "gradients_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients_1/Reshape_14_grad/Reshape" + input: "gradients_1/concat_1_grad/ConcatOffset" + input: "gradients_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_1/Reshape_14_grad/Reshape" + input: "gradients_1/concat_1_grad/ConcatOffset:1" + input: "gradients_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_2_type_0/mul_grad/Reshape" + input: "gradients_1/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/concat_1_grad/Slice" + input: "gradients_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_1/concat_1_grad/Slice_1" + input: "gradients_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients_1/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients_1/Reshape_8_grad/Reshape" + input: "gradients_1/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients_1/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_2_type_0/add_grad/Shape" + input: "gradients_1/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients_1/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_2_type_0/add_grad/Sum" + input: "gradients_1/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_5_grad/Rank" + input: "gradients_1/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients_1/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_5_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_5_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_0/transpose_grad/transpose" + input: "gradients_1/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_5_grad/Rank" + input: "gradients_1/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients_1/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_5_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_5_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_1/transpose_grad/transpose" + input: "gradients_1/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/AddN" + op: "AddN" + input: "gradients_1/add_5_grad/Reshape" + input: "gradients_1/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/add_4_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_4_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/add_4_grad/Shape" + input: "gradients_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_4_grad/Sum" + op: "Sum" + input: "gradients_1/AddN" + input: "gradients_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/add_4_grad/Sum" + input: "gradients_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN" + input: "gradients_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/add_4_grad/Sum_1" + input: "gradients_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_1_type_0/mul_grad/Shape" + input: "gradients_1/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_1/add_4_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_1/layer_1_type_0/mul_grad/Mul" + input: "gradients_1/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_1_type_0/mul_grad/Sum" + input: "gradients_1/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_1_type_0/mul_grad/Reshape" + input: "gradients_1/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients_1/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_1_type_0/add_grad/Shape" + input: "gradients_1/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients_1/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_1_type_0/add_grad/Sum" + input: "gradients_1/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/AddN_1" + op: "AddN" + input: "gradients_1/add_4_grad/Reshape" + input: "gradients_1/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_1" + input: "gradients_1/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients_1/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_0_type_0/add_grad/Shape" + input: "gradients_1/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients_1/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_0_type_0/add_grad/Sum" + input: "gradients_1/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients_1/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_1/Slice_2_grad/Rank" + input: "gradients_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_1/Slice_2_grad/Shape_1" + input: "gradients_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_1/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/Slice_2_grad/sub_1" + input: "gradients_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_1/Slice_2_grad/Reshape" + input: "gradients_1/Slice_2_grad/Reshape_1" + input: "gradients_1/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 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_1/Reshape_15_grad/Reshape" + input: "gradients_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_1/Slice_2_grad/Pad" + input: "gradients_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/concat_grad/mod" + input: "gradients_1/concat_grad/ShapeN" + input: "gradients_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/concat_grad/Slice" + op: "Slice" + input: "gradients_1/Reshape_13_grad/Reshape" + input: "gradients_1/concat_grad/ConcatOffset" + input: "gradients_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients_1/Reshape_13_grad/Reshape" + input: "gradients_1/concat_grad/ConcatOffset:1" + input: "gradients_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/concat_grad/Slice" + input: "gradients_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_1/concat_grad/Slice_1" + input: "gradients_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_1/Reshape_7_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_1/Reshape_11_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients_1/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients_1/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_8_grad/Shape" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients_1/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_8_grad/Sum" + input: "gradients_1/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients_1/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients_1/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_8_grad/Shape" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients_1/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_8_grad/Sum" + input: "gradients_1/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_4_grad/Rank" + input: "gradients_1/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients_1/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_4_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_4_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients_1/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_4_grad/Rank" + input: "gradients_1/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients_1/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_4_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_4_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients_1/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_2" + op: "AddN" + input: "gradients_1/filter_type_0/Slice_5_grad/Pad" + input: "gradients_1/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/mul_grad/Shape" + input: "gradients_1/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_1/AddN_2" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/mul_grad/Mul" + input: "gradients_1/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/mul_grad/Sum" + input: "gradients_1/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_3" + op: "AddN" + input: "gradients_1/filter_type_1/Slice_5_grad/Pad" + input: "gradients_1/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/mul_grad/Shape" + input: "gradients_1/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_1/AddN_3" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/mul_grad/Mul" + input: "gradients_1/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/mul_grad/Sum" + input: "gradients_1/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_10_grad/Shape" + input: "gradients_1/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/mul_grad/Reshape" + input: "gradients_1/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_10_grad/Sum" + input: "gradients_1/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/mul_grad/Reshape" + input: "gradients_1/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_10_grad/Sum_1" + input: "gradients_1/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_10_grad/Shape" + input: "gradients_1/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/mul_grad/Reshape" + input: "gradients_1/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_10_grad/Sum" + input: "gradients_1/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/mul_grad/Reshape" + input: "gradients_1/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_10_grad/Sum_1" + input: "gradients_1/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients_1/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients_1/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_3_grad/Shape" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients_1/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_3_grad/Sum" + input: "gradients_1/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients_1/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients_1/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_7_grad/Shape" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients_1/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_7_grad/Sum" + input: "gradients_1/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients_1/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients_1/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_3_grad/Shape" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients_1/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_3_grad/Sum" + input: "gradients_1/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients_1/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients_1/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_7_grad/Shape" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients_1/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_7_grad/Sum" + input: "gradients_1/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/add_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_4_grad/Shape" + input: "gradients_1/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_1/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_4_grad/Sum" + input: "gradients_1/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_1/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_4_grad/Sum_1" + input: "gradients_1/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_9_grad/Shape" + input: "gradients_1/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_9_grad/Sum" + input: "gradients_1/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_9_grad/Sum_1" + input: "gradients_1/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/add_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_4_grad/Shape" + input: "gradients_1/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_1/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_4_grad/Sum" + input: "gradients_1/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_1/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_4_grad/Sum_1" + input: "gradients_1/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_9_grad/Shape" + input: "gradients_1/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_9_grad/Sum" + input: "gradients_1/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_9_grad/Sum_1" + input: "gradients_1/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_4_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_9_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_4_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_9_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients_1/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients_1/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients_1/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients_1/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_3_grad/Shape" + input: "gradients_1/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_3_grad/Sum" + input: "gradients_1/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_8_grad/Shape" + input: "gradients_1/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_8_grad/Sum" + input: "gradients_1/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_3_grad/Shape" + input: "gradients_1/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_3_grad/Sum" + input: "gradients_1/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_8_grad/Shape" + input: "gradients_1/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_8_grad/Sum" + input: "gradients_1/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/AddN_4" + op: "AddN" + input: "gradients_1/filter_type_0/add_4_grad/Reshape" + input: "gradients_1/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_2_grad/Shape" + input: "gradients_1/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_4" + input: "gradients_1/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_2_grad/Sum" + input: "gradients_1/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_4" + input: "gradients_1/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_2_grad/Sum_1" + input: "gradients_1/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_5" + op: "AddN" + input: "gradients_1/filter_type_0/add_9_grad/Reshape" + input: "gradients_1/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_7_grad/Shape" + input: "gradients_1/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_5" + input: "gradients_1/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_7_grad/Sum" + input: "gradients_1/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_5" + input: "gradients_1/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_7_grad/Sum_1" + input: "gradients_1/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_6" + op: "AddN" + input: "gradients_1/filter_type_1/add_4_grad/Reshape" + input: "gradients_1/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_2_grad/Shape" + input: "gradients_1/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_6" + input: "gradients_1/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_2_grad/Sum" + input: "gradients_1/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_6" + input: "gradients_1/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_2_grad/Sum_1" + input: "gradients_1/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_7" + op: "AddN" + input: "gradients_1/filter_type_1/add_9_grad/Reshape" + input: "gradients_1/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_7_grad/Shape" + input: "gradients_1/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_7" + input: "gradients_1/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_7_grad/Sum" + input: "gradients_1/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_7" + input: "gradients_1/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_7_grad/Sum_1" + input: "gradients_1/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/concat_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat/axis" + input: "gradients_1/filter_type_0/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/filter_type_0/concat_grad/mod" + input: "gradients_1/filter_type_0/concat_grad/ShapeN" + input: "gradients_1/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_grad/Slice" + op: "Slice" + input: "gradients_1/filter_type_0/add_2_grad/Reshape" + input: "gradients_1/filter_type_0/concat_grad/ConcatOffset" + input: "gradients_1/filter_type_0/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/concat_grad/Slice_1" + op: "Slice" + input: "gradients_1/filter_type_0/add_2_grad/Reshape" + input: "gradients_1/filter_type_0/concat_grad/ConcatOffset:1" + input: "gradients_1/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_2_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_1/axis" + input: "gradients_1/filter_type_0/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/filter_type_0/concat_1_grad/mod" + input: "gradients_1/filter_type_0/concat_1_grad/ShapeN" + input: "gradients_1/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_1_grad/Slice" + op: "Slice" + input: "gradients_1/filter_type_0/add_7_grad/Reshape" + input: "gradients_1/filter_type_0/concat_1_grad/ConcatOffset" + input: "gradients_1/filter_type_0/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_1/filter_type_0/add_7_grad/Reshape" + input: "gradients_1/filter_type_0/concat_1_grad/ConcatOffset:1" + input: "gradients_1/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_7_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/concat_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat/axis" + input: "gradients_1/filter_type_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/filter_type_1/concat_grad/mod" + input: "gradients_1/filter_type_1/concat_grad/ShapeN" + input: "gradients_1/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_grad/Slice" + op: "Slice" + input: "gradients_1/filter_type_1/add_2_grad/Reshape" + input: "gradients_1/filter_type_1/concat_grad/ConcatOffset" + input: "gradients_1/filter_type_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients_1/filter_type_1/add_2_grad/Reshape" + input: "gradients_1/filter_type_1/concat_grad/ConcatOffset:1" + input: "gradients_1/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_2_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_1/axis" + input: "gradients_1/filter_type_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/filter_type_1/concat_1_grad/mod" + input: "gradients_1/filter_type_1/concat_1_grad/ShapeN" + input: "gradients_1/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients_1/filter_type_1/add_7_grad/Reshape" + input: "gradients_1/filter_type_1/concat_1_grad/ConcatOffset" + input: "gradients_1/filter_type_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_1/filter_type_1/add_7_grad/Reshape" + input: "gradients_1/filter_type_1/concat_1_grad/ConcatOffset:1" + input: "gradients_1/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_7_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients_1/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients_1/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients_1/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients_1/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_1_grad/Shape" + input: "gradients_1/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_1_grad/Sum" + input: "gradients_1/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_6_grad/Shape" + input: "gradients_1/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_6_grad/Sum" + input: "gradients_1/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_1_grad/Shape" + input: "gradients_1/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_1_grad/Sum" + input: "gradients_1/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_6_grad/Shape" + input: "gradients_1/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_6_grad/Sum" + input: "gradients_1/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/AddN_8" + op: "AddN" + input: "gradients_1/filter_type_0/concat_grad/Slice" + input: "gradients_1/filter_type_0/concat_grad/Slice_1" + input: "gradients_1/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_8" + input: "gradients_1/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_9" + op: "AddN" + input: "gradients_1/filter_type_0/concat_1_grad/Slice" + input: "gradients_1/filter_type_0/concat_1_grad/Slice_1" + input: "gradients_1/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_9" + input: "gradients_1/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_10" + op: "AddN" + input: "gradients_1/filter_type_1/concat_grad/Slice" + input: "gradients_1/filter_type_1/concat_grad/Slice_1" + input: "gradients_1/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_10" + input: "gradients_1/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_11" + op: "AddN" + input: "gradients_1/filter_type_1/concat_1_grad/Slice" + input: "gradients_1/filter_type_1/concat_1_grad/Slice_1" + input: "gradients_1/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_11" + input: "gradients_1/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients_1/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients_1/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients_1/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients_1/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_grad/Shape" + input: "gradients_1/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_grad/Sum" + input: "gradients_1/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_5_grad/Shape" + input: "gradients_1/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_5_grad/Sum" + input: "gradients_1/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_grad/Shape" + input: "gradients_1/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_grad/Sum" + input: "gradients_1/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_5_grad/Shape" + input: "gradients_1/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_5_grad/Sum" + input: "gradients_1/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_grad/MatMul" + input: "gradients_1/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients_1/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_grad/MatMul" + input: "gradients_1/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients_1/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_1_grad/Rank" + input: "gradients_1/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients_1/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_1_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_1_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_3_grad/Rank" + input: "gradients_1/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients_1/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_3_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_3_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_1_grad/Rank" + input: "gradients_1/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients_1/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_1_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_1_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_3_grad/Rank" + input: "gradients_1/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients_1/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_3_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_3_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_1_grad/Pad" + input: "gradients_1/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_3_grad/Pad" + input: "gradients_1/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_1_grad/Pad" + input: "gradients_1/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_3_grad/Pad" + input: "gradients_1/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_12" + op: "AddN" + input: "gradients_1/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_grad/Rank" + input: "gradients_1/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients_1/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_grad/Reshape_1" + input: "gradients_1/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients_1/AddN_12" + input: "gradients_1/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_13" + op: "AddN" + input: "gradients_1/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_2_grad/Rank" + input: "gradients_1/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients_1/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_2_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_2_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_1/AddN_13" + input: "gradients_1/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_14" + op: "AddN" + input: "gradients_1/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_grad/Rank" + input: "gradients_1/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients_1/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_grad/Reshape_1" + input: "gradients_1/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_1/AddN_14" + input: "gradients_1/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_15" + op: "AddN" + input: "gradients_1/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_2_grad/Rank" + input: "gradients_1/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients_1/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_2_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_2_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_1/AddN_15" + input: "gradients_1/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_16" + op: "AddN" + input: "gradients_1/filter_type_0/Slice_grad/Pad" + input: "gradients_1/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_1/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_16" + input: "gradients_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_17" + op: "AddN" + input: "gradients_1/filter_type_1/Slice_grad/Pad" + input: "gradients_1/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_1/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_17" + input: "gradients_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_grad/stack" + op: "Pack" + input: "gradients_1/Slice_grad/Rank" + input: "gradients_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/sub" + op: "Sub" + input: "gradients_1/Slice_grad/Shape_1" + input: "gradients_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_1/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/Slice_grad/sub_1" + input: "gradients_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_1/Slice_grad/Reshape" + input: "gradients_1/Slice_grad/Reshape_1" + input: "gradients_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_1/Reshape_5_grad/Reshape" + input: "gradients_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_1/Slice_1_grad/Rank" + input: "gradients_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_1/Slice_1_grad/Shape_1" + input: "gradients_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_1/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/Slice_1_grad/sub_1" + input: "gradients_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_1/Slice_1_grad/Reshape" + input: "gradients_1/Slice_1_grad/Reshape_1" + input: "gradients_1/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 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_1/Reshape_9_grad/Reshape" + input: "gradients_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_18" + op: "AddN" + input: "gradients_1/Slice_grad/Pad" + input: "gradients_1/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_1/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_18" + input: "gradients_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_35/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_35/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_35/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_35" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_35/stack" + input: "strided_slice_35/stack_1" + input: "strided_slice_35/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_24/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_24" + op: "Mul" + input: "strided_slice_35" + input: "mul_24/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_27/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_27/shape" + op: "Pack" + input: "Reshape_27/shape/0" + input: "mul_24" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_27" + op: "Reshape" + input: "gradients_1/Reshape_4_grad/Reshape" + input: "Reshape_27/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA_1" + op: "ProdForceSeA" + input: "Reshape_27" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA_1" + op: "ProdVirialSeA" + input: "Reshape_27" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_36/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_36/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_36/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_36" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_36/stack" + input: "strided_slice_36/stack_1" + input: "strided_slice_36/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_25/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_25" + op: "Mul" + input: "mul_25/x" + input: "strided_slice_36" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_28/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_28/shape" + op: "Pack" + input: "Reshape_28/shape/0" + input: "mul_25" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_28" + op: "Reshape" + input: "ProdForceSeA_1" + input: "Reshape_28/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_29/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_29" + op: "Reshape" + input: "ProdVirialSeA_1" + input: "Reshape_29/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_37/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_37/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_37/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_37" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_37/stack" + input: "strided_slice_37/stack_1" + input: "strided_slice_37/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_26/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_26" + op: "Mul" + input: "mul_26/x" + input: "strided_slice_37" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_30/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_30/shape" + op: "Pack" + input: "Reshape_30/shape/0" + input: "mul_26" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_30" + op: "Reshape" + input: "ProdVirialSeA_1:1" + input: "Reshape_30/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Shape" + op: "Shape" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients_2/grad_ys_0" + op: "Fill" + input: "gradients_2/Shape" + input: "gradients_2/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/zeros_like" + op: "ZerosLike" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/zeros_like_1" + op: "ZerosLike" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/split_grad/concat" + op: "ConcatV2" + input: "gradients_2/zeros_like" + input: "gradients_2/zeros_like_1" + input: "gradients_2/grad_ys_0" + input: "split/split_dim" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_22_grad/Shape" + op: "Shape" + input: "o_dipole" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients_2/split_grad/concat" + input: "gradients_2/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/o_dipole_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/o_dipole_grad/Reshape" + op: "Reshape" + input: "gradients_2/Reshape_22_grad/Reshape" + input: "gradients_2/o_dipole_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_21_grad/Shape" + op: "Shape" + input: "Reshape_18" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients_2/o_dipole_grad/Reshape" + input: "gradients_2/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients_2/Reshape_21_grad/Reshape" + input: "gradients_2/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients_2/Reshape_18_grad/Reshape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_17" + input: "gradients_2/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/MatMul_grad/Shape" + input: "gradients_2/MatMul_grad/strided_slice/stack" + input: "gradients_2/MatMul_grad/strided_slice/stack_1" + input: "gradients_2/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/MatMul_grad/Shape_1" + input: "gradients_2/MatMul_grad/strided_slice_1/stack" + input: "gradients_2/MatMul_grad/strided_slice_1/stack_1" + input: "gradients_2/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/MatMul_grad/strided_slice" + input: "gradients_2/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/Sum" + op: "Sum" + input: "gradients_2/MatMul_grad/MatMul" + input: "gradients_2/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients_2/MatMul_grad/Sum" + input: "gradients_2/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients_2/MatMul_grad/MatMul_1" + input: "gradients_2/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/MatMul_grad/Sum_1" + input: "gradients_2/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients_2/MatMul_grad/Reshape" + input: "gradients_2/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients_2/MatMul_grad/Reshape_1" + input: "gradients_2/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/final_layer_type_0/add_grad/Shape" + input: "gradients_2/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/Reshape_17_grad/Reshape" + input: "gradients_2/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/final_layer_type_0/add_grad/Sum" + input: "gradients_2/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_3_grad/stack" + op: "Pack" + input: "gradients_2/Slice_3_grad/Rank" + input: "gradients_2/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients_2/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/sub" + op: "Sub" + input: "gradients_2/Slice_3_grad/Shape_1" + input: "gradients_2/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_2/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/Slice_3_grad/sub_1" + input: "gradients_2/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_2/Slice_3_grad/Reshape" + input: "gradients_2/Slice_3_grad/Reshape_1" + input: "gradients_2/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 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_2/Reshape_16_grad/Reshape" + input: "gradients_2/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_2/Slice_3_grad/Pad" + input: "gradients_2/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_5_grad/Shape" + op: "Shape" + input: "add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_5_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/add_5_grad/Shape" + input: "gradients_2/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_5_grad/Sum" + op: "Sum" + input: "gradients_2/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_2/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/add_5_grad/Sum" + input: "gradients_2/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_5_grad/Sum_1" + op: "Sum" + input: "gradients_2/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_2/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/add_5_grad/Sum_1" + input: "gradients_2/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_2_type_0/mul_grad/Shape" + input: "gradients_2/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_2/add_5_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_2/layer_2_type_0/mul_grad/Mul" + input: "gradients_2/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_2_type_0/mul_grad/Sum" + input: "gradients_2/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients_2/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/concat_1_grad/mod" + input: "gradients_2/concat_1_grad/ShapeN" + input: "gradients_2/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/concat_1_grad/Slice" + op: "Slice" + input: "gradients_2/Reshape_14_grad/Reshape" + input: "gradients_2/concat_1_grad/ConcatOffset" + input: "gradients_2/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_2/Reshape_14_grad/Reshape" + input: "gradients_2/concat_1_grad/ConcatOffset:1" + input: "gradients_2/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_2_type_0/mul_grad/Reshape" + input: "gradients_2/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/concat_1_grad/Slice" + input: "gradients_2/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_2/concat_1_grad/Slice_1" + input: "gradients_2/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients_2/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients_2/Reshape_8_grad/Reshape" + input: "gradients_2/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients_2/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_2_type_0/add_grad/Shape" + input: "gradients_2/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients_2/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_2_type_0/add_grad/Sum" + input: "gradients_2/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_5_grad/Rank" + input: "gradients_2/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients_2/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_5_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_5_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_0/transpose_grad/transpose" + input: "gradients_2/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_5_grad/Rank" + input: "gradients_2/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients_2/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_5_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_5_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_1/transpose_grad/transpose" + input: "gradients_2/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/AddN" + op: "AddN" + input: "gradients_2/add_5_grad/Reshape" + input: "gradients_2/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/add_4_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_4_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/add_4_grad/Shape" + input: "gradients_2/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_4_grad/Sum" + op: "Sum" + input: "gradients_2/AddN" + input: "gradients_2/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/add_4_grad/Sum" + input: "gradients_2/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN" + input: "gradients_2/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/add_4_grad/Sum_1" + input: "gradients_2/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_1_type_0/mul_grad/Shape" + input: "gradients_2/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_2/add_4_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_2/layer_1_type_0/mul_grad/Mul" + input: "gradients_2/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_1_type_0/mul_grad/Sum" + input: "gradients_2/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_1_type_0/mul_grad/Reshape" + input: "gradients_2/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients_2/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_1_type_0/add_grad/Shape" + input: "gradients_2/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients_2/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_1_type_0/add_grad/Sum" + input: "gradients_2/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/AddN_1" + op: "AddN" + input: "gradients_2/add_4_grad/Reshape" + input: "gradients_2/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_1" + input: "gradients_2/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients_2/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_0_type_0/add_grad/Shape" + input: "gradients_2/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients_2/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_0_type_0/add_grad/Sum" + input: "gradients_2/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients_2/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_2_grad/stack" + op: "Pack" + input: "gradients_2/Slice_2_grad/Rank" + input: "gradients_2/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients_2/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/sub" + op: "Sub" + input: "gradients_2/Slice_2_grad/Shape_1" + input: "gradients_2/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_2/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/Slice_2_grad/sub_1" + input: "gradients_2/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_2/Slice_2_grad/Reshape" + input: "gradients_2/Slice_2_grad/Reshape_1" + input: "gradients_2/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 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_2/Reshape_15_grad/Reshape" + input: "gradients_2/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_2/Slice_2_grad/Pad" + input: "gradients_2/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients_2/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/concat_grad/mod" + input: "gradients_2/concat_grad/ShapeN" + input: "gradients_2/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/concat_grad/Slice" + op: "Slice" + input: "gradients_2/Reshape_13_grad/Reshape" + input: "gradients_2/concat_grad/ConcatOffset" + input: "gradients_2/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/concat_grad/Slice_1" + op: "Slice" + input: "gradients_2/Reshape_13_grad/Reshape" + input: "gradients_2/concat_grad/ConcatOffset:1" + input: "gradients_2/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/concat_grad/Slice" + input: "gradients_2/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_2/concat_grad/Slice_1" + input: "gradients_2/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_2/Reshape_7_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_2/Reshape_11_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients_2/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients_2/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_8_grad/Shape" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients_2/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_8_grad/Sum" + input: "gradients_2/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients_2/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients_2/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_8_grad/Shape" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients_2/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_8_grad/Sum" + input: "gradients_2/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_4_grad/Rank" + input: "gradients_2/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients_2/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_4_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_4_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients_2/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_4_grad/Rank" + input: "gradients_2/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients_2/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_4_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_4_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients_2/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_2" + op: "AddN" + input: "gradients_2/filter_type_0/Slice_5_grad/Pad" + input: "gradients_2/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/mul_grad/Shape" + input: "gradients_2/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_2/AddN_2" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/mul_grad/Mul" + input: "gradients_2/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/mul_grad/Sum" + input: "gradients_2/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_3" + op: "AddN" + input: "gradients_2/filter_type_1/Slice_5_grad/Pad" + input: "gradients_2/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/mul_grad/Shape" + input: "gradients_2/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_2/AddN_3" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/mul_grad/Mul" + input: "gradients_2/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/mul_grad/Sum" + input: "gradients_2/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_10_grad/Shape" + input: "gradients_2/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/mul_grad/Reshape" + input: "gradients_2/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_10_grad/Sum" + input: "gradients_2/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/mul_grad/Reshape" + input: "gradients_2/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_10_grad/Sum_1" + input: "gradients_2/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_10_grad/Shape" + input: "gradients_2/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/mul_grad/Reshape" + input: "gradients_2/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_10_grad/Sum" + input: "gradients_2/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/mul_grad/Reshape" + input: "gradients_2/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_10_grad/Sum_1" + input: "gradients_2/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients_2/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients_2/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_3_grad/Shape" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients_2/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_3_grad/Sum" + input: "gradients_2/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients_2/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients_2/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_7_grad/Shape" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients_2/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_7_grad/Sum" + input: "gradients_2/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients_2/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients_2/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_3_grad/Shape" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients_2/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_3_grad/Sum" + input: "gradients_2/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients_2/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients_2/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_7_grad/Shape" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients_2/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_7_grad/Sum" + input: "gradients_2/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/add_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_4_grad/Shape" + input: "gradients_2/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_2/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_4_grad/Sum" + input: "gradients_2/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_2/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_4_grad/Sum_1" + input: "gradients_2/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_9_grad/Shape" + input: "gradients_2/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_9_grad/Sum" + input: "gradients_2/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_9_grad/Sum_1" + input: "gradients_2/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/add_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_4_grad/Shape" + input: "gradients_2/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_2/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_4_grad/Sum" + input: "gradients_2/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_2/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_4_grad/Sum_1" + input: "gradients_2/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_9_grad/Shape" + input: "gradients_2/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_9_grad/Sum" + input: "gradients_2/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_9_grad/Sum_1" + input: "gradients_2/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_4_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_9_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_4_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_9_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients_2/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients_2/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients_2/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients_2/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_3_grad/Shape" + input: "gradients_2/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_3_grad/Sum" + input: "gradients_2/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_8_grad/Shape" + input: "gradients_2/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_8_grad/Sum" + input: "gradients_2/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_3_grad/Shape" + input: "gradients_2/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_3_grad/Sum" + input: "gradients_2/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_8_grad/Shape" + input: "gradients_2/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_8_grad/Sum" + input: "gradients_2/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/AddN_4" + op: "AddN" + input: "gradients_2/filter_type_0/add_4_grad/Reshape" + input: "gradients_2/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_2_grad/Shape" + input: "gradients_2/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_4" + input: "gradients_2/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_2_grad/Sum" + input: "gradients_2/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_4" + input: "gradients_2/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_2_grad/Sum_1" + input: "gradients_2/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_5" + op: "AddN" + input: "gradients_2/filter_type_0/add_9_grad/Reshape" + input: "gradients_2/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_7_grad/Shape" + input: "gradients_2/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_5" + input: "gradients_2/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_7_grad/Sum" + input: "gradients_2/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_5" + input: "gradients_2/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_7_grad/Sum_1" + input: "gradients_2/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_6" + op: "AddN" + input: "gradients_2/filter_type_1/add_4_grad/Reshape" + input: "gradients_2/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_2_grad/Shape" + input: "gradients_2/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_6" + input: "gradients_2/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_2_grad/Sum" + input: "gradients_2/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_6" + input: "gradients_2/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_2_grad/Sum_1" + input: "gradients_2/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_7" + op: "AddN" + input: "gradients_2/filter_type_1/add_9_grad/Reshape" + input: "gradients_2/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/add_9_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_7_grad/Shape" + input: "gradients_2/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_7" + input: "gradients_2/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_7_grad/Sum" + input: "gradients_2/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_7" + input: "gradients_2/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_7_grad/Sum_1" + input: "gradients_2/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/concat_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat/axis" + input: "gradients_2/filter_type_0/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/filter_type_0/concat_grad/mod" + input: "gradients_2/filter_type_0/concat_grad/ShapeN" + input: "gradients_2/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_grad/Slice" + op: "Slice" + input: "gradients_2/filter_type_0/add_2_grad/Reshape" + input: "gradients_2/filter_type_0/concat_grad/ConcatOffset" + input: "gradients_2/filter_type_0/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/concat_grad/Slice_1" + op: "Slice" + input: "gradients_2/filter_type_0/add_2_grad/Reshape" + input: "gradients_2/filter_type_0/concat_grad/ConcatOffset:1" + input: "gradients_2/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_2_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_1/axis" + input: "gradients_2/filter_type_0/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/filter_type_0/concat_1_grad/mod" + input: "gradients_2/filter_type_0/concat_1_grad/ShapeN" + input: "gradients_2/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_1_grad/Slice" + op: "Slice" + input: "gradients_2/filter_type_0/add_7_grad/Reshape" + input: "gradients_2/filter_type_0/concat_1_grad/ConcatOffset" + input: "gradients_2/filter_type_0/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_2/filter_type_0/add_7_grad/Reshape" + input: "gradients_2/filter_type_0/concat_1_grad/ConcatOffset:1" + input: "gradients_2/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_7_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/concat_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat/axis" + input: "gradients_2/filter_type_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/filter_type_1/concat_grad/mod" + input: "gradients_2/filter_type_1/concat_grad/ShapeN" + input: "gradients_2/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_grad/Slice" + op: "Slice" + input: "gradients_2/filter_type_1/add_2_grad/Reshape" + input: "gradients_2/filter_type_1/concat_grad/ConcatOffset" + input: "gradients_2/filter_type_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients_2/filter_type_1/add_2_grad/Reshape" + input: "gradients_2/filter_type_1/concat_grad/ConcatOffset:1" + input: "gradients_2/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_2_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_1/axis" + input: "gradients_2/filter_type_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/filter_type_1/concat_1_grad/mod" + input: "gradients_2/filter_type_1/concat_1_grad/ShapeN" + input: "gradients_2/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients_2/filter_type_1/add_7_grad/Reshape" + input: "gradients_2/filter_type_1/concat_1_grad/ConcatOffset" + input: "gradients_2/filter_type_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_2/filter_type_1/add_7_grad/Reshape" + input: "gradients_2/filter_type_1/concat_1_grad/ConcatOffset:1" + input: "gradients_2/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_7_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients_2/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients_2/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients_2/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients_2/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_1_grad/Shape" + input: "gradients_2/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_1_grad/Sum" + input: "gradients_2/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_6_grad/Shape" + input: "gradients_2/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_6_grad/Sum" + input: "gradients_2/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_1_grad/Shape" + input: "gradients_2/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_1_grad/Sum" + input: "gradients_2/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_6_grad/Shape" + input: "gradients_2/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_6_grad/Sum" + input: "gradients_2/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/AddN_8" + op: "AddN" + input: "gradients_2/filter_type_0/concat_grad/Slice" + input: "gradients_2/filter_type_0/concat_grad/Slice_1" + input: "gradients_2/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_8" + input: "gradients_2/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_9" + op: "AddN" + input: "gradients_2/filter_type_0/concat_1_grad/Slice" + input: "gradients_2/filter_type_0/concat_1_grad/Slice_1" + input: "gradients_2/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_9" + input: "gradients_2/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_10" + op: "AddN" + input: "gradients_2/filter_type_1/concat_grad/Slice" + input: "gradients_2/filter_type_1/concat_grad/Slice_1" + input: "gradients_2/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_10" + input: "gradients_2/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_11" + op: "AddN" + input: "gradients_2/filter_type_1/concat_1_grad/Slice" + input: "gradients_2/filter_type_1/concat_1_grad/Slice_1" + input: "gradients_2/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_11" + input: "gradients_2/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients_2/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients_2/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients_2/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients_2/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_grad/Shape" + input: "gradients_2/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_grad/Sum" + input: "gradients_2/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_5_grad/Shape" + input: "gradients_2/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_5_grad/Sum" + input: "gradients_2/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_grad/Shape" + input: "gradients_2/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_grad/Sum" + input: "gradients_2/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_5_grad/Shape" + input: "gradients_2/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_5_grad/Sum" + input: "gradients_2/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_grad/MatMul" + input: "gradients_2/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients_2/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_grad/MatMul" + input: "gradients_2/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients_2/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_1_grad/Rank" + input: "gradients_2/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients_2/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_1_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_1_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_3_grad/Rank" + input: "gradients_2/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients_2/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_3_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_3_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_1_grad/Rank" + input: "gradients_2/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients_2/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_1_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_1_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_3_grad/Rank" + input: "gradients_2/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients_2/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_3_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_3_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_1_grad/Pad" + input: "gradients_2/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_3_grad/Pad" + input: "gradients_2/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_1_grad/Pad" + input: "gradients_2/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_3_grad/Pad" + input: "gradients_2/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_12" + op: "AddN" + input: "gradients_2/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_grad/Rank" + input: "gradients_2/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients_2/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_grad/Reshape_1" + input: "gradients_2/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients_2/AddN_12" + input: "gradients_2/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_13" + op: "AddN" + input: "gradients_2/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_2_grad/Rank" + input: "gradients_2/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients_2/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_2_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_2_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_2/AddN_13" + input: "gradients_2/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_14" + op: "AddN" + input: "gradients_2/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_grad/Rank" + input: "gradients_2/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients_2/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_grad/Reshape_1" + input: "gradients_2/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_2/AddN_14" + input: "gradients_2/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_15" + op: "AddN" + input: "gradients_2/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_2_grad/Rank" + input: "gradients_2/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients_2/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_2_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_2_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_2/AddN_15" + input: "gradients_2/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_16" + op: "AddN" + input: "gradients_2/filter_type_0/Slice_grad/Pad" + input: "gradients_2/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_2/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_16" + input: "gradients_2/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_17" + op: "AddN" + input: "gradients_2/filter_type_1/Slice_grad/Pad" + input: "gradients_2/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_2/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_17" + input: "gradients_2/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_grad/stack" + op: "Pack" + input: "gradients_2/Slice_grad/Rank" + input: "gradients_2/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients_2/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/sub" + op: "Sub" + input: "gradients_2/Slice_grad/Shape_1" + input: "gradients_2/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/sub_1" + op: "Sub" + input: "gradients_2/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/Slice_grad/sub_1" + input: "gradients_2/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_2/Slice_grad/Reshape" + input: "gradients_2/Slice_grad/Reshape_1" + input: "gradients_2/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/Pad" + op: "Pad" + input: "gradients_2/Reshape_5_grad/Reshape" + input: "gradients_2/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_1_grad/stack" + op: "Pack" + input: "gradients_2/Slice_1_grad/Rank" + input: "gradients_2/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients_2/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/sub" + op: "Sub" + input: "gradients_2/Slice_1_grad/Shape_1" + input: "gradients_2/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_2/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/Slice_1_grad/sub_1" + input: "gradients_2/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_2/Slice_1_grad/Reshape" + input: "gradients_2/Slice_1_grad/Reshape_1" + input: "gradients_2/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 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_2/Reshape_9_grad/Reshape" + input: "gradients_2/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_18" + op: "AddN" + input: "gradients_2/Slice_grad/Pad" + input: "gradients_2/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_2/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_18" + input: "gradients_2/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_38/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_38/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_38/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_38" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_38/stack" + input: "strided_slice_38/stack_1" + input: "strided_slice_38/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_27/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_27" + op: "Mul" + input: "strided_slice_38" + input: "mul_27/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_31/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_31/shape" + op: "Pack" + input: "Reshape_31/shape/0" + input: "mul_27" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_31" + op: "Reshape" + input: "gradients_2/Reshape_4_grad/Reshape" + input: "Reshape_31/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA_2" + op: "ProdForceSeA" + input: "Reshape_31" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA_2" + op: "ProdVirialSeA" + input: "Reshape_31" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_39/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_39/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_39/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_39" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_39/stack" + input: "strided_slice_39/stack_1" + input: "strided_slice_39/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_28/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_28" + op: "Mul" + input: "mul_28/x" + input: "strided_slice_39" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_32/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_32/shape" + op: "Pack" + input: "Reshape_32/shape/0" + input: "mul_28" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_32" + op: "Reshape" + input: "ProdForceSeA_2" + input: "Reshape_32/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_33/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_33" + op: "Reshape" + input: "ProdVirialSeA_2" + input: "Reshape_33/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_40/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_40/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_40/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_40" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_40/stack" + input: "strided_slice_40/stack_1" + input: "strided_slice_40/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_29/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_29" + op: "Mul" + input: "mul_29/x" + input: "strided_slice_40" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_34/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_34/shape" + op: "Pack" + input: "Reshape_34/shape/0" + input: "mul_29" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_34" + op: "Reshape" + input: "ProdVirialSeA_2:1" + input: "Reshape_34/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "o_force/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "o_force" + op: "ConcatV2" + input: "Reshape_24" + input: "Reshape_28" + input: "Reshape_32" + input: "o_force/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "o_virial/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "o_virial" + op: "ConcatV2" + input: "Reshape_25" + input: "Reshape_29" + input: "Reshape_33" + input: "o_virial/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "o_atom_virial/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "o_atom_virial" + op: "ConcatV2" + input: "Reshape_26" + input: "Reshape_30" + input: "Reshape_34" + input: "o_atom_virial/axis" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +library { +} +versions { +} diff --git a/source/tests/infer/deeppolar_new.pbtxt b/source/tests/infer/deeppolar_new.pbtxt new file mode 100644 index 0000000000..f680add745 --- /dev/null +++ b/source/tests/infer/deeppolar_new.pbtxt @@ -0,0 +1,151920 @@ +node { + name: "t_box" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "t_coord" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "t_type" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "t_natoms" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 4 + } + } + } + } +} +node { + name: "t_mesh" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + } + } + } +} +node { + name: "model_attr/tmap" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "O H" + } + } + } +} +node { + name: "model_attr/sel_type" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "model_attr/model_type" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "polar" + } + } + } +} +node { + name: "model_attr/model_version" + op: "Const" + attr { + key: "dtype" + value { + type: DT_STRING + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_STRING + tensor_shape { + } + string_val: "1.0" + } + } + } +} +node { + name: "model_attr/output_dim" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "add/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "add" + op: "AddV2" + input: "add/x" + input: "strided_slice" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "descrpt_attr/rcut" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 6.0 + } + } + } +} +node { + name: "descrpt_attr/ntypes" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "descrpt_attr/t_avg" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 2 + } + dim { + size: 552 + } + } + tensor_content: "!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\234\375s\226\220\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\216\025\237.[\304?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + } + } + } +} +node { + name: "descrpt_attr/t_avg/read" + op: "Identity" + input: "descrpt_attr/t_avg" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@descrpt_attr/t_avg" + } + } + } +} +node { + name: "descrpt_attr/t_std" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 2 + } + dim { + size: 552 + } + } + tensor_content: "\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\033\240\347\271.\262\304?\221\177B\2125\330\300?\221\177B\2125\330\300?\221\177B\2125\330\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?\253\301\263Q\251C\303?\000;Y\330[.\300?\000;Y\330[.\300?\000;Y\330[.\300?" + } + } + } +} +node { + name: "descrpt_attr/t_std/read" + op: "Identity" + input: "descrpt_attr/t_std" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@descrpt_attr/t_std" + } + } + } +} +node { + name: "strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_1" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul" + op: "Mul" + input: "strided_slice_1" + input: "mul/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape/shape" + op: "Pack" + input: "Reshape/shape/0" + input: "mul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape" + op: "Reshape" + input: "t_coord" + input: "Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_1/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\377\377\377\377\t\000\000\000" + } + } + } +} +node { + name: "Reshape_1" + op: "Reshape" + input: "t_box" + input: "Reshape_1/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_2/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_2/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_2/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_2" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Reshape_2/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_2/shape" + op: "Pack" + input: "Reshape_2/shape/0" + input: "strided_slice_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_2" + op: "Reshape" + input: "t_type" + input: "Reshape_2/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdEnvMatA" + op: "ProdEnvMatA" + input: "Reshape" + input: "Reshape_2" + input: "t_natoms" + input: "Reshape_1" + input: "t_mesh" + input: "descrpt_attr/t_avg/read" + input: "descrpt_attr/t_std/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "rcut_a" + value { + f: -1.0 + } + } + attr { + key: "rcut_r" + value { + f: 6.0 + } + } + attr { + key: "rcut_r_smth" + value { + f: 5.800000190734863 + } + } + attr { + key: "sel_a" + value { + list { + i: 46 + i: 92 + } + } + } + attr { + key: "sel_r" + value { + list { + i: 0 + i: 0 + } + } + } +} +node { + name: "Reshape_3/shape" + op: "Const" + 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(\002\000\000" + } + } + } +} +node { + name: "Reshape_3" + op: "Reshape" + input: "ProdEnvMatA" + input: "Reshape_3/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "o_rmat" + op: "Identity" + input: "Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "o_rmat_deriv" + op: "Identity" + input: "ProdEnvMatA:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "o_rij" + op: "Identity" + input: "ProdEnvMatA:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "o_nlist" + op: "Identity" + input: "ProdEnvMatA:3" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_3/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_3/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_3/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_3" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_1/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_1" + op: "Mul" + input: "mul_1/x" + input: "strided_slice_3" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_4/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_4/shape" + op: "Pack" + input: "Reshape_4/shape/0" + input: "mul_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_4" + op: "Reshape" + input: "o_rmat" + input: "Reshape_4/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_4/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_4/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_4/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_4" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_2/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_2" + op: "Mul" + input: "strided_slice_4" + input: "mul_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Slice/begin" + op: "Const" + 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: "Slice/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice/size" + op: "Pack" + input: "Slice/size/0" + input: "mul_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice" + op: "Slice" + input: "Reshape_4" + input: "Slice/begin" + input: "Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_5/shape" + op: "Const" + 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(\002\000\000" + } + } + } +} +node { + name: "Reshape_5" + op: "Reshape" + input: "Slice" + input: "Reshape_5/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Slice/begin" + op: "Const" + 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: "filter_type_0/Slice/size" + op: "Const" + 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\270\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice" + op: "Slice" + input: "Reshape_5" + input: "filter_type_0/Slice/begin" + input: "filter_type_0/Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape/shape" + op: "Const" + 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\004\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape" + op: "Reshape" + input: "filter_type_0/Slice" + input: "filter_type_0/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Slice_1/begin" + op: "Const" + 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: "filter_type_0/Slice_1/size" + op: "Const" + 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: "filter_type_0/Slice_1" + op: "Slice" + input: "filter_type_0/Reshape" + input: "filter_type_0/Slice_1/begin" + input: "filter_type_0/Slice_1/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_1/shape" + op: "Const" + 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: "filter_type_0/Reshape_1" + op: "Reshape" + input: "filter_type_0/Slice_1" + input: "filter_type_0/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/matrix_1_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "L\337\242-\310\334\230\277\324\222\2675J\352\336?\017\034\334\210\351Z\350\277fi\323E\034e\213?\242\257\361\271v\221\321?" + } + } + } +} +node { + name: "filter_type_0/matrix_1_0/read" + op: "Identity" + input: "filter_type_0/matrix_1_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_1_0" + } + } + } +} +node { + name: "filter_type_0/bias_1_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "Z\025\357X\3201\327\277_R/h\n\301\376\277\251\220\261\304\022O\347\277|\3501J\021$\330\277\254T\366\235\334\256\361\277" + } + } + } +} +node { + name: "filter_type_0/bias_1_0/read" + op: "Identity" + input: "filter_type_0/bias_1_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_1_0" + } + } + } +} +node { + name: "filter_type_0/MatMul" + op: "MatMul" + input: "filter_type_0/Reshape_1" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add" + op: "AddV2" + input: "filter_type_0/MatMul" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh" + op: "Tanh" + input: "filter_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_2/shape" + op: "Const" + 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\005\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_2" + op: "Reshape" + input: "filter_type_0/Tanh" + input: "filter_type_0/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/matrix_2_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 5 + } + dim { + size: 10 + } + } + tensor_content: "\023\341\ns\322\352\262\277Q\203\332\032\226\253\266?I5\246$%\367\320\277,\330i\263\375\362\305?\023\025\235P\256\355\277\277B_\346\232\222\272\343\277\320\211_A\264\222\302?r\021\230\367\341\246\224\277iiT\262\261\362\306?\314O\356]\026@\332?\341\231\030q\247\263\330?\261\026\347>\361q\302?\300\360\363\017M}\335?\353mD8\005I\341?\205\027~a\331)\326\277F\261\356\370\205\310\273\2778\021l^!\301\320\277(\177xH\000\271\300\277\225\351\351^JD\340?\312\210\277Qf\006\334\277C\363\006D\n\221\222\277;\326Co\253(\320\277[\367\354\244N\243\274\277\212\337\276\235\361G\314?V\030K>\305\006\247?Y\022\302\314\371\252\322?`j0\016|\316\341\277\005\227\362\206m\005\276?>\377h\246\237\n\334?7\027~?\233\364\337?m\262J=\332A\310\277\322\334\034nZ\265\332?\231#\206\037d\222\305\277\221\321r\370e\274\327\277F\217S\275+\352\311\277\362\003p\3651d\305\277\0046\020\334\246\303\306\277\275}\\\275w<\340\277F\315<\364\236F\226?\027\304\272Y\351\346\321\277\014\025\362I\"\361\265\277\314\202]\035n\331\320\277\255\3735\276U\231\264?\346G\271\255h\"\272\277\2665\005kk7\311?\"V%U\357\207\330\277!\255\\4m\021\320\277t\272\315\267V\202\312\277\r#Ni\266\363\321\277\377U\201\263\257j\311\277" + } + } + } +} +node { + name: "filter_type_0/matrix_2_0/read" + op: "Identity" + input: "filter_type_0/matrix_2_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_2_0" + } + } + } +} +node { + name: "filter_type_0/bias_2_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\362Bl\326>\262\364\2773\r\371N5\025\353\277\325\202Df\250\337\316?\210\242\376\242\341\204\320\277\247\271J,\033;\360\277J\313\272\342\264\213\341?\334&Q\231`\245\333?`\026\372\021w\221\356?\'\364\353\320,\016\375?\217\330M6\366\375\352\277" + } + } + } +} +node { + name: "filter_type_0/bias_2_0/read" + op: "Identity" + input: "filter_type_0/bias_2_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_2_0" + } + } + } +} +node { + name: "filter_type_0/MatMul_1" + op: "MatMul" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_1" + op: "AddV2" + input: "filter_type_0/MatMul_1" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_1" + op: "Tanh" + input: "filter_type_0/add_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_3/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_3" + op: "Reshape" + input: "filter_type_0/Tanh_1" + input: "filter_type_0/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_0/concat" + op: "ConcatV2" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/add_2" + op: "AddV2" + input: "filter_type_0/concat" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/matrix_3_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 20 + } + } + tensor_content: "8\020\367\315>_\312?\224G\373\026\231\354\270\277&,\252\351\376\337\302?:\320[\377\305\376\320?\223\274\376\237\244\205\246?\227\2643Kh\301u?\260\243\016q\365\034\321?\024\367\014XF\204\263\277\243\263!\253\374\032\300\277\235\025W\024$)\311\277\320\211\0028{\007\303?H\301\322D>F\266?Ip\356\301\2509\276\277\315\273?\347\324\276\234\252y\330\277\024\376\346=F\323\341\277\230x\341!b\244\243?\201\246\260\203\327\014\325\2772g\364#\030\316d\277\302Tp\2773\316\301\277]d\202\335\241~|?\240og\217\220\013\316\277\207\306\025S\177\002\310?\225\317\365e\244\211\304\277G\244x\257\250\375\231\277K}\246\205*,\260\277TO\023\246\023\267\311?\353Y\031\"\272\244\321?_D\265\2505.\270\277Vr=\243\337\276\246?\001\263\246U\331&\300\277\005\271\005\025?\006\310?z1\230O\334\330\300\277/\254g u\231\314?\337!\237\002\034\336m\277q\023=>\243\322r\277\003\r\353\376\266U\306?Z:\004?o\262U\277\013<\340\3177\000\320\277C\372}}\221B\305\277\032l\203\327\324\301\321\277\313;\024A\335\303\311\277\304x\003\357\361\014\307?\234\225\223]\233\354\261\277h0\313\335m\260\321\27727-\301\341\276\247?\302J\3226_\342\324\277\203\340\260\222\341v\342?\277v\306\206\272\226\271\277\004\027\3677LT\312?s~\341n\347|\330\277.\013\224\320\200\327\323?9\347\332pP\222\323\277\372Q\362\222\325\325\301?VG\357\177\227\342\270\277.\371\335\026v\264\232?\256V>\334[K\255?\377\327\2668\310\001\312\277\230\364\361\207Y6\332?\367t\247u\3441\340\277\214\335\336\241\374\006\324\277\005*O\312\'\262\314\277\353z\0144|\364\324\277e\202\216\355]u\245\277\333\360\007\323\321\332\312?\326A=/b\270\254?a\334\327#\351\216\220?\336-\274G\032\037\342?q\225\315u\373{x\277~LTG2b\255\277\362d\236\253\257\001\333\277\006DC4ag\275?\344\305\270?\376\233\260?\371G\253wk3\216?A\327\244\366\345O\266?$\253\034;$6\320\277)G\232y\226]\330?\264\222\351\264\022\030\312?`6N+P\271\304\277\235\0301B\237G\264\277\231\337\374\212(!\260?\256\014\271\251\224\"\330\277\210\366\2548\247`\301?\346}\263\337\344\212\322?\266\371R\222s\251\272\277$\213%A\024[\250\277\274\013>\312\337|\216?@\343b\343\tv\310\277W\212\323l\323\351\321?\316\335\307/_\212\300\277^AN\020\013\024\301\277\373\'7\374\222\347\221\277\374\273\"\255\200\266\311\277\315\315s;\364T\316?\204\250\256\242\267\016\300?\365\003\013x=X\246?\363$\240)\325\206\231\277RA\266\223\337\305?\223>L\004n\035\300\277\204\003\336 \355B\256?L\014\007\262\363.\315\277\353zV\036+f\266\277\t\035\354E\342\006\272?\353J\373\332\270\266\313\2779`\313\252\363\006\311\277\331\301\221sy\364\302?q\362\210\361\245\354\232\277yN\241g\373\310\231?\214\2774\016\216\345\271\277\250\334\000~h!\253\277\204\255\274\330\357(\273?\326V\355j#\325\316\277\2113\214k\005\211\273\2773\203T\323n\354\226\277\326\337g\3235\353\320?\276>\245\267\335\316\273\277]\002s\217\264\267\262?\374\037;\314\027\236\273\277\320\331~\324\3640\310?\241=\2122\265\221\267\277\213Pp\231\325\301\300\277\340\360$I\306x\331\277\275\022W\2549\221\271\277~\366\013\373\315y\320?4\326(\323\203\021\251\277\256\223c\\\030\rq\277!\221\004X\230\006\266\277\230\235|\235 \325\323\277\226P\001\264W\354\271\277t\323w\'\0328\314?\334}\305\nv13?\002\314B\3479\177\300?\006\232\226\357\370\014\327\277G\237\257\020o5\312?\'\267\221\367\335\350\320?c\202|\213P\372\312?" + } + } + } +} +node { + name: "filter_type_0/matrix_3_0/read" + op: "Identity" + input: "filter_type_0/matrix_3_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_3_0" + } + } + } +} +node { + name: "filter_type_0/bias_3_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 20 + } + } + tensor_content: "\262b\"\021\377\304\321?\2570?c\371\321\352?\240\340~\350\002\225\366?\340e\216R\345\035\337?c\354\217w\016\366\373\277\325\022\3057rz\365?\3711\231\333c\227\372?\234\211\366\014\246+\345\277\'n\250#\275\224\324\277\363\354b\337\376\206\321\277\200\232\371^\315\276\236\277\342\343\263\2656|\345\277I\227T\323a\236\377?$\353\311D[\256\312\277L\217\222\214\226\220\323\277\237\217\317#\260\370\303?\372\306\251\341\337\314\344?\200E\305\010\273\225\364\277\003\310\003\014\232\027\357?\2078\036$2\321\363?" + } + } + } +} +node { + name: "filter_type_0/bias_3_0/read" + op: "Identity" + input: "filter_type_0/bias_3_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_3_0" + } + } + } +} +node { + name: "filter_type_0/MatMul_2" + op: "MatMul" + input: "filter_type_0/add_2" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_3" + op: "AddV2" + input: "filter_type_0/MatMul_2" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_2" + op: "Tanh" + input: "filter_type_0/add_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_4/shape" + op: "Const" + 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\024\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_4" + op: "Reshape" + input: "filter_type_0/Tanh_2" + input: "filter_type_0/Reshape_4/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/concat_1/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_0/concat_1" + op: "ConcatV2" + input: "filter_type_0/add_2" + input: "filter_type_0/add_2" + input: "filter_type_0/concat_1/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/add_4" + op: "AddV2" + input: "filter_type_0/concat_1" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_5/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377.\000\000\000\024\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_5" + op: "Reshape" + input: "filter_type_0/add_4" + input: "filter_type_0/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Reshape_6/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377.\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_6" + op: "Reshape" + input: "filter_type_0/Slice" + input: "filter_type_0/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/MatMul_3" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_0/Slice_2/begin" + op: "Const" + 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\270\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice_2/size" + op: "Const" + 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\377p\001\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice_2" + op: "Slice" + input: "Reshape_5" + input: "filter_type_0/Slice_2/begin" + input: "filter_type_0/Slice_2/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_7/shape" + op: "Const" + 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\004\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_7" + op: "Reshape" + input: "filter_type_0/Slice_2" + input: "filter_type_0/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Slice_3/begin" + op: "Const" + 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: "filter_type_0/Slice_3/size" + op: "Const" + 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: "filter_type_0/Slice_3" + op: "Slice" + input: "filter_type_0/Reshape_7" + input: "filter_type_0/Slice_3/begin" + input: "filter_type_0/Slice_3/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_8/shape" + op: "Const" + 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: "filter_type_0/Reshape_8" + op: "Reshape" + input: "filter_type_0/Slice_3" + input: "filter_type_0/Reshape_8/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/matrix_1_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "\316_23C\236\330?\245SZ\233d\246\331\277$\346\201\272\364\376\323?\357Y\010)~7\362?\300/\273\373\223\260~\277" + } + } + } +} +node { + name: "filter_type_0/matrix_1_1/read" + op: "Identity" + input: "filter_type_0/matrix_1_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_1_1" + } + } + } +} +node { + name: "filter_type_0/bias_1_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "@W\020\271e\010\351\277W^\377,\337\322\315\277\273\231\335\3436\353\260\277\274\273\214h\277\235\372\277\001\310\374\235dv\231?" + } + } + } +} +node { + name: "filter_type_0/bias_1_1/read" + op: "Identity" + input: "filter_type_0/bias_1_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_1_1" + } + } + } +} +node { + name: "filter_type_0/MatMul_4" + op: "MatMul" + input: "filter_type_0/Reshape_8" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_5" + op: "AddV2" + input: "filter_type_0/MatMul_4" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_3" + op: "Tanh" + input: "filter_type_0/add_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_9/shape" + op: "Const" + 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\005\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_9" + op: "Reshape" + input: "filter_type_0/Tanh_3" + input: "filter_type_0/Reshape_9/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/matrix_2_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 5 + } + dim { + size: 10 + } + } + tensor_content: "\2255\341$\221\350\320?{g\252\333!\251\220\277\245\316o\302\306\377\305\2775\317t\331\363\314\323?\240jo%8\216\207\277\315\000\340\210\211\355\254\277\372\331\nb\376.\252\277\317{\340\267\322Y\323\277\321+\256z1a\302\277\247\352\0308\325\275\313?\314U\177\367\367{\243\277\010\241\356y\200\006\306\277\255\277\250i!\032\314\2771=n$\001r\321?T\001\207+\205\311\321\277\340*\225\336n`\256\277\257\026J\010\265\254\213\277\313\244\367\362\211=\266\277\031\230i\311&\224\343?=\276DI\247y\334?\251\341\336k%\013\303\277\233\364\321r-\324\314?\231\344p[\357?\277?\362\024\227qa1\305?m_~gB\236\251?\034\021\274i\004J\325\277\0241%\2634\330\331?R\367\0212\353\352\342\277\371\314P\365M&\270?\352Y\031\322<\r\273\277y-\251\337}\332\344\277o\374g\017 \034\337\277\354\221\247\206\310h\315?\'.>\375\363<\340\277,g\211\017q\236\245?\315\255X\177O=\262\277\027Z\244>\202\252\322?\010\330v\370oe\314\277\346vi\\\265:\325?\021\260\'l\022\035\215?\227\024\200\007\343p\307\277\367\213?[}\344\321?\0171\003/$\270\264\277\242\000\215\032K\023\315\277\317\2439^2~\312?Jz\373\264\257\241\231?\022m\326-\263(\242?\315\217\363Y\257\343\250\277\365\210\227\377\036X\261\277\375}\250\233*S\330\277" + } + } + } +} +node { + name: "filter_type_0/matrix_2_1/read" + op: "Identity" + input: "filter_type_0/matrix_2_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/matrix_2_1" + } + } + } +} +node { + name: "filter_type_0/bias_2_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\312\357\007\311M[\350\277\353\357\320D\256)\346?`\027m\241\3432\274\277T\33525\326\225\310?\205b\255\276D*\363?\307n\240\317\022\013\001\300\336Y\014\216\336\330\336\277\237L\313\030\220\177\340?R\230&\352\022\324\334?R%yg\331\367\303?" + } + } + } +} +node { + name: "filter_type_0/bias_2_1/read" + op: "Identity" + input: "filter_type_0/bias_2_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_2_1" + } + } + } +} +node { + name: "filter_type_0/MatMul_5" + op: "MatMul" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_6" + op: "AddV2" + input: "filter_type_0/MatMul_5" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_4" + op: "Tanh" + input: "filter_type_0/add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_10/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_10" + op: "Reshape" + input: "filter_type_0/Tanh_4" + input: "filter_type_0/Reshape_10/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/concat_2/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_0/concat_2" + op: "ConcatV2" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/concat_2/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/add_7" + op: "AddV2" + input: "filter_type_0/concat_2" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/matrix_3_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 20 + } + } + tensor_content: "\017\030(x\002\334\264\277W\272\273\276\004\001\320\277\213\030s\303\301s\254?d\251\356\217\000j\316\277P\321\227\3079_\305\277q\377\2529d\333\334\277;\363\032\315\0167\302?l}k/L\350\300\277\217\312\245+\334\263\303\277\325!\312\354\255\021\277?\312u\n\257R\340\305\277\342\265\2566i\335\263?NL\004)P\354\310\277\303\242\006&g\200\226\277\221o\3406\032\245\245?\037\224\243\267\316\017\311?\014U\251.\3428\315?\020\006\001XL\036\220\277\264\341\335\312\035\246\302\277\021J\341\231\031\225\324?\312\235\313ct\202\304?V\0274\213\200C\321\277P\255k\005j\334\261\277\236 =c\232\217\265?@`a|\215\216\277?\271Iz\035$\357\225\277K\033\332\234\373\354\224\277U\\t\2227Y\274?\275\342\213\277\272\240\246\277\322\307\202\365M_\262?Q-.O\344\327\301?\215\023\244\355\202\322\302?\252\335\307\254\026\235\311?\270\357\270\310\210\317\266?P\342\303D\341\251\301\277\210\007+\315\'\360\320?/\221r\017c:\325\277h\350\013\304Nr\326?\316K\266\240QK\234?\244\034\274\r;\261\327?\327YM!\332\002\313\277\'\377sZ\035E\342?r\302\033\2363$\262\277\254\t\245v\202\340\320\277<\027\275\240\016-\326?z\341\275\273a\026\275?\324\n\2152\362\312\317?\367:B\336\312\202\311?\304C\034\267\353\340\320\277v^\362d\343&\265?\013\360\271l\227\237&\277\325\177\244;\033V\220\277X\357\303\330\021\273\265?\240\200\226\302\262\267\266\277\277\340\216\213\305\266\231?\206$\351s,\223\245\277.\350\\\201\312\351\255?W\277\216}|@\301\277\024\231+\257\314\021\300\277\022\305\377\007oc\222?\333\016#\370\317\025\235?:\000{\0318\351\270?:\242\t\207\"\250\301\277/\014\0164\222\314\345\277\307\037xybh5?\361\237\342\301;\266\325?\300\3378\247_\352\337?\002\326\265\216\235\225\271\277C\305\306\200!\023\326?\325)\307D\211U\305\277\354=\253\376\037\030\337?\343c\014\\Jm\316\277\301T{\314\267.\321\277N;\202\343]S\334\277\236=I\272\354\225\247?PN75\351x\305\277\032\212\t\270\313\361\300?\213\n`\226J\222\306\277\322\013j\375\343\202\320\277\222qx\250\246\234\333\277=\356\021/\342\334\301?\021\237\273\230\325\233\311?\351S\266\203\321\236\261?}\026\224|\211\346\260?\303{=x\210l\261\277<\3556\327\007\333\315?:\rzKMU\340?\336f\3100\215\006\260?\327^m\022\253i\276\277p\362h\325j\014\267?y\214\r\314\343\367\263?OU\252\3555T\312?\232\222>\341\222\304\262\277\340m\260\027\200\031\314\277\n\'\306\252\223\014\324\277(b\306\265\217\323\304?]\027c\345\013L\235\277\347\370uV\350\345\273\277>\005j\324\304\211\324\277\242\226&\364\030\315\265?\263\250\203\031o\347\334\277\t\371H\311M!\232\277\267Z\003\371b\277\234?\365\3549\315Y\204\304\2779\351\030\017\334$\314?d\264\336\215\356\t\320\277]\322,\312{\026\302\277}pYs\256\324\327?n\031M\353\026]\306\277\226\337\371\357\253\256\303\277\271\377A\320\247z\303\277\227\007;\327\225\"\312?eM\263,*\315\306?\271\371\311\250\350\231\314\277\311\257\237\006J^\306\277u\263\374\313F \333? o;\362\014l\251?\001\224~\267\365\026\307?4\\\323\3069\206\300?\324\220/\210\344\202\234?\236!6l\364\376\310\277W7\316\3631\203\330\277Z\346\004m\211\267\245?q\275)\316\366\327\265\277\377oP\224A\020\274?{\022\301|\331W\337\277\320\036\201\200\252$\310\277\374Q\310`\223\256\240\277\324\221,\222\310\204\312\277\010\225 \215\ni\306?}\3152\226\263\010\261?\243,#\240Sw\342\277\260\234\002\265>\013\264\277\354\325\004\277Td\300\277\265el\263*\360\306?\340\241\300\266\332H\231?\312\232\005m\037\245\313\277n\352\3154\213h\255?0\327\020\253\374\027\327?F\335:\221\322$\301\277\372\202$\t\365j\323?\227;\247\251\014\207\261?O\222\033\227\010\247\220?gQ\241_B\354\315?\034\315D\245\240\217\251?\013V\003\377\r\354\301?\027\317\232tg\320\300?\004aT\333\'\237\321\277\375x\027\3628\"\315\277\025\337\374\037#\221\314?\255cMz8:\300\277K\002\257:\205B\304\277\207\366\315\272\231\220\260?\321ex\343\326|\220?~\266\311\243\000\215\310\277W\327#\301\273+\310\277\320\014KY\212o\270\277\376\'\034;F.\311\277\214\223@\320\206-\320?\241\021v\264By\340?\376P\256\031\212\024\313\277W,>5\355T\333?\r\263\003\352O \304\277IB\016\366;b\343\277\020\275x\334\226\272\261\277\365_l\251\233ax?\013h\022=\234k\303?\210\250\275\256\262\257\261?\217\360\375\276m\347\300?\3006\030\304\353p\321\277\3058n{=Z\271\277\353\354*\252\037>\261??\204\365?\303\002\211\022\264n\363?&\2025w\307\311\350?\220\252\245M\022A\001@\017\221\356\2300j\351?" + } + } + } +} +node { + name: "filter_type_0/bias_3_1/read" + op: "Identity" + input: "filter_type_0/bias_3_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_0/bias_3_1" + } + } + } +} +node { + name: "filter_type_0/MatMul_6" + op: "MatMul" + input: "filter_type_0/add_7" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_8" + op: "AddV2" + input: "filter_type_0/MatMul_6" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Tanh_5" + op: "Tanh" + input: "filter_type_0/add_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_11/shape" + op: "Const" + 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\024\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_11" + op: "Reshape" + input: "filter_type_0/Tanh_5" + input: "filter_type_0/Reshape_11/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/concat_3/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_0/concat_3" + op: "ConcatV2" + input: "filter_type_0/add_7" + input: "filter_type_0/add_7" + input: "filter_type_0/concat_3/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/add_9" + op: "AddV2" + input: "filter_type_0/concat_3" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Reshape_12/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\\\000\000\000\024\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_12" + op: "Reshape" + input: "filter_type_0/add_9" + input: "filter_type_0/Reshape_12/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/Reshape_13/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\\\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Reshape_13" + op: "Reshape" + input: "filter_type_0/Slice_2" + input: "filter_type_0/Reshape_13/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/MatMul_7" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_0/add_10" + op: "AddV2" + input: "filter_type_0/MatMul_3" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/mul/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 0.007246376811594203 + } + } + } +} +node { + name: "filter_type_0/mul" + op: "Mul" + input: "filter_type_0/add_10" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Slice_4/begin" + op: "Const" + 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: "filter_type_0/Slice_4/size" + op: "Const" + 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\377\377\377\377\020\000\000\000" + } + } + } +} +node { + name: "filter_type_0/Slice_4" + op: "Slice" + input: "filter_type_0/mul" + input: "filter_type_0/Slice_4/begin" + input: "filter_type_0/Slice_4/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/Slice_5/begin" + op: "Const" + 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: "filter_type_0/Slice_5/size" + op: "Const" + 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\003\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "filter_type_0/Slice_5" + op: "Slice" + input: "filter_type_0/mul" + input: "filter_type_0/Slice_5/begin" + input: "filter_type_0/Slice_5/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_0/transpose/perm" + op: "Const" + 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\001\000\000\000" + } + } + } +} +node { + name: "filter_type_0/transpose" + op: "Transpose" + input: "filter_type_0/Slice_5" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_0/MatMul_8" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_0/Reshape_14/shape" + op: "Const" + 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" + } + } + } +} +node { + name: "filter_type_0/Reshape_14" + op: "Reshape" + input: "filter_type_0/MatMul_8" + input: "filter_type_0/Reshape_14/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_7/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_7/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_7/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_7" + op: "StridedSlice" + input: "Shape_1" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_8/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_8/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_8/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_8" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_3/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 320 + } + } + } +} +node { + name: "mul_3" + op: "Mul" + input: "strided_slice_8" + input: "mul_3/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_7/shape" + op: "Pack" + input: "strided_slice_7" + input: "mul_3" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_7" + op: "Reshape" + input: "filter_type_0/Reshape_14" + input: "Reshape_7/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Shape_2" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_9/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_9/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_9/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_9" + op: "StridedSlice" + input: "Shape_2" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_10/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_10/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_10/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_10" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_4/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 20 + } + } + } +} +node { + name: "mul_4" + op: "Mul" + input: "strided_slice_10" + input: "mul_4/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_5/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_5" + op: "Mul" + input: "mul_4" + input: "mul_5/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_8/shape" + op: "Pack" + input: "strided_slice_9" + input: "mul_5" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_8" + op: "Reshape" + input: "filter_type_0/transpose" + input: "Reshape_8/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_11/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_11/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_11/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_11" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "add_1/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "add_1" + op: "AddV2" + input: "add_1/x" + input: "strided_slice_11" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_6/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_6" + op: "Mul" + input: "add_1" + input: "mul_6/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_12/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_12/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 4 + } + } + } +} +node { + name: "strided_slice_12/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_12" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_7/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_7" + op: "Mul" + input: "strided_slice_12" + input: "mul_7/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Slice_1/begin/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "Slice_1/begin" + op: "Pack" + input: "Slice_1/begin/0" + input: "mul_6" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_1/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice_1/size" + op: "Pack" + input: "Slice_1/size/0" + input: "mul_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_1" + op: "Slice" + input: "Reshape_4" + input: "Slice_1/begin" + input: "Slice_1/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_9/shape" + op: "Const" + 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(\002\000\000" + } + } + } +} +node { + name: "Reshape_9" + op: "Reshape" + input: "Slice_1" + input: "Reshape_9/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/Slice/begin" + op: "Const" + 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: "filter_type_1/Slice/size" + op: "Const" + 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\270\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Slice" + op: "Slice" + input: "Reshape_9" + input: "filter_type_1/Slice/begin" + input: "filter_type_1/Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape/shape" + op: "Const" + 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\004\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape" + op: "Reshape" + input: "filter_type_1/Slice" + input: "filter_type_1/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/Slice_1/begin" + op: "Const" + 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: "filter_type_1/Slice_1/size" + op: "Const" + 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: "filter_type_1/Slice_1" + op: "Slice" + input: "filter_type_1/Reshape" + input: "filter_type_1/Slice_1/begin" + input: "filter_type_1/Slice_1/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_1/shape" + op: "Const" + 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: "filter_type_1/Reshape_1" + op: "Reshape" + input: "filter_type_1/Slice_1" + input: "filter_type_1/Reshape_1/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/matrix_1_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "\303\232\"W\250z\307\277\001t\325\320/\211\345?\000M8\315\315\251\272?\204\210\242h\020\017\222\277\224g\266qL\314\335\277" + } + } + } +} +node { + name: "filter_type_1/matrix_1_0/read" + op: "Identity" + input: "filter_type_1/matrix_1_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_1_0" + } + } + } +} +node { + name: "filter_type_1/bias_1_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "\230\325\2407\274\331\330\277\244\326\356\274\247\035\337\277\212v\302\216\311R\353?\303\307\031\024\344\303\271?eD\207\371\257R\326\277" + } + } + } +} +node { + name: "filter_type_1/bias_1_0/read" + op: "Identity" + input: "filter_type_1/bias_1_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_1_0" + } + } + } +} +node { + name: "filter_type_1/MatMul" + op: "MatMul" + input: "filter_type_1/Reshape_1" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add" + op: "AddV2" + input: "filter_type_1/MatMul" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh" + op: "Tanh" + input: "filter_type_1/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_2/shape" + op: "Const" + 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\005\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_2" + op: "Reshape" + input: "filter_type_1/Tanh" + input: "filter_type_1/Reshape_2/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/matrix_2_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 5 + } + dim { + size: 10 + } + } + tensor_content: "\353\n\021\301\004\'\316?Z\324\200\203\353J\301?\2245\263\027QJ\332?\264C\212\253\272A\326\277\341\0168\341d\207\344?\340\244\n\210n\221\274?\352y\261\320\r\034\314?\302\034\226Y\375z\270\277\3570i\361\3655\340?qc[B\2743\224?\263\306\023\325Q\005\323?\335\230\213\216O\200\274?fb\347e\271O\263\277\360J\034p%\265\262\277\371\245\361\302\267]\330\277\356\231$\306I}\312?\334\354\244\274\321;\310\2774\206|+\027;\326?\232;o\224\306\356\317?\217\nrL\226\363\265\2774\237\221\206\000\364\322?{\335\361\325\302*\272\277y\312\212Q\313\275\337\2779\177`6\007V\300\277=\"J#\366\016\322?\007b\032\2475\177\242\277;v\371\334Us\262\277\n^y\315\354_\304?I\314mEA\343\200?\327\374\347r\271\276\312\277\031\211;\270\241\227\276?\031\034P\372\033\007\315\277v\257\n?\316v\301\277\241\222\261\325:-\303?Ef\"\017\303\024\300?\004\205cu?\345\306\277\330G\027\303\2153\301?\273m\335\013\025X\326\277\263\311_\231\330\344\324\277Q\261\317\333g\226\332\277(\356\334\377\242$\243\277v\235\315\372\336z\301\277\220E \232\035\200\273\277\350Y\315\013!v\276\277\250\332\007\221/B\261\277+\345]Y\274\024S\277V\333@)L~\324\277\233k\250\264%W\323\277P\037\362\021^\016\303\277(\002\r\023\320x\337?" + } + } + } +} +node { + name: "filter_type_1/matrix_2_0/read" + op: "Identity" + input: "filter_type_1/matrix_2_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_2_0" + } + } + } +} +node { + name: "filter_type_1/bias_2_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\371\203E\253\275z\345\277\255\327\375\306\231a\320?\n\t\237\336\202t\336\277\233fh\246V:\327\277\213M\250\230\373\340\342?\247\307\177\360\276\033\346\277\265\036g$\222\343\363\277\372\ty\325\265\007\304\277\367J0Is\357\255?\333A\245\274vc\340\277" + } + } + } +} +node { + name: "filter_type_1/bias_2_0/read" + op: "Identity" + input: "filter_type_1/bias_2_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_2_0" + } + } + } +} +node { + name: "filter_type_1/MatMul_1" + op: "MatMul" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_1" + op: "AddV2" + input: "filter_type_1/MatMul_1" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh_1" + op: "Tanh" + input: "filter_type_1/add_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_3/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_3" + op: "Reshape" + input: "filter_type_1/Tanh_1" + input: "filter_type_1/Reshape_3/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_1/concat" + op: "ConcatV2" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/add_2" + op: "AddV2" + input: "filter_type_1/concat" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/matrix_3_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 20 + } + } + tensor_content: "\275(}%\000\207\270?\352yzw|N\204?\355\2348\303\002\324\271\277\213_\362\037\3174\274?\372*\241\303\313\303\264\2778\273\276\261\272m\262\277\241\304w\036\351\016\331?\315\333\252Z$\361\254?\251\315{\216\213\017\301\277\327\334%j\345\376\304?\327417\033D\223?bR\013\210#V\247\277\017s\3638j\324\220?D\211\372\377m\256\323\277*\240\260\377@\337\335?\213\270s\346\322\314\203\277\2409\354\245\354\232\306\277\326c\001\313\207Y\322?t\255\225\207\367\023\320\277\032\347\247\316\364\206\247?\310\233P@Y^\306?\3742\330FC\316\312\277\001E\351\337\375\323\262?\263\031\366\031\216.\251??\271T\354\332?\233?\275\256G\'\372\031\275\277\236\307\325\035\007\330\335?\240\224|)\026\260\323?\022\177@\231`\210\247?\243\336\021*~\337\273\277\0249-]\221a\313\277s\3374\325\020\325\326?\226xB\003\377\345\243?\31588\354\235cQ\277\177W\215\305\215\337\267?%\202KV\273\313\332\277z\363\222\263\270\033\272?E\214U\221\266a\263\277\020\2236\314+\362\301?\235)$\302U\217\314\277\207\216\376\372_\375\224?\322\366~\325\022\214\331?\307\274\332\314\2470\313\277\037\236H\024\230\307\321?\200\3745\r\241\222\263?\353\256bIX\303\323?\257\376\022\277\232\020\325\277\366:U\353K\226\301?\364\357\205?\014N\303\277\316\301\242\306C\324\331?34\367\354rE\251\2778/\210\024\237\316\261?\313\263\213\251b\303y?\315}R\202i\336\260\277\236t\n\315\341\303\322\277YZw\'\270%\306?\245\313d]\235\372\270\277\241N\340\354ND\263\277\335Ap\227\353\304\322?\365K\323b\021w\272?ty\231\005\025E\201?]w\200\0211\245\274?J\026\201R\314\372\312?\t\312G\034\307\325\314\277\r\374V\274\277\220\300\277\223D\320 \267\271\267?\327>1\250\023g\331\277\207k`(\223Y\272?\255\311\220\275\207\346\231\277+\307\350\267\000J\323\277<\254:U\242\317\325\277\317]Y\307\007\253z?}H\002\371\372\361\321\277\354\367e\312\333\224k?4\002\\\337\342\245\301\277\347>\246\177\353\323\313\277\273\260h\237\210\201\327\277\033g\325jM\367\307?nL\275s^l\271\277\204\013\273\335\375\020\253\277\\p\331\020\245&\267\277\264\344\247\177F\305\310\277\304\315\257N\274\037\305\27780u\240R!\306\277<\037\375\212\340\020\303\277\264\215h\357^\255\277\277LI\325\352\321\003|\277F?\322\254\257\007\261\277S\264?@#G\324\277\305\221\205\222\271f\256?n!\201{\302\340\245?\315\244\233\3632\367\310\277\243\302\355he\214\301\2778qR\223\355\345\260?\361\344\372R\311\353\302?\226ujE@\033\276\277n\276\3238\226\303\244?\220:\333_c\227\271?\277\252z\204\013\232\315\277J\255\261\374Kt\242\277\303\2133\365\032\202\254?4G\001\254-\320\325\277\032\270\232R\2206\317?\331\266P)\006j\276\277\234\356mk\036\006\324?\250?\032\320\325\263\262?h\334V\305\243\255\303?\300\376\332~~8\320\277\312\370D`z\211d?\230\016R\340\204\265\326?\032\353G\244\232\327\204\277\316\310\010\235[P\306?A\332\351\240\010v\276\277\342~\361y\014q\311\277\267Q\253n\035(\323?\034+\336)=U\302?b\333\344O,\255\303?\t\205H\335\231\020\244?\361\367E\330\305cb?yhYx/\347\304?\347\365\331\302?\334\252\277yh\237~\017\377\277?\274{tW\207\233\323\277n\325B\375\326\324\320\2779\350\205xz7\226\277\376r\215=\273\374f?\222}\310\250\024\321\304?\315\227\020\365\220I\311?\263I\355]\017E\261\277G1o\361\350\256\316?\202\230U\335\337\r\310\277\270\024&{0\262\304?yo\257\002\231\251\320\277\351\361\224\320\001\032\323\277\031\021\277\313\304\271\326\277l\377W3e\365\267\277Q\335\374\016\'\300\304?\245\304\370\244\021Q\311\277\214x^w\320\005\305?V]\275d @\307\277\022\22428\350\311\227?D\030\177)\322\244\255?>ii\317\352\366\324\277\317`\262\274\264\237\231\277\263\317\371\020\306\021\310?\003*\341\022\215Z\273\277\256\2503\234.\032\246\277\300\301\007A\r\302\232?\311#\252\363}\243\247\277/-\306\014|\303\310\277\320c\373\370\212\022\264\277Y\277\340\027\217\316\303\277\337\245\361\346c\240\255\277\300LO\307\357\201\302?\264<\374\242!\237\300\2775n\300\274\032\200\250?\213q=\242\'bv\277\252G\234\032_\222\320\2771\372\347\366k\260\323\277\305\263\021\2527\312\314?F6\321x\3068\321?\026\001\"s\272\336\322?W\325@\316,\360}\277s`\266\251\325l\300?\351\311\2548s\026\227?\213\215\245\235\0106\315\277\2523S\030U\324\300?M\027Q\323\027{\266\277\\\006\252\373\2267\262?8wM\311\266\345\306\277\222\022\326\240ws\270?\324\361\362\375I\324\323?C\364\'\266\267|\263?\032\350\'\371\177\243\324\277\371\370W\365al\273\277\245\216\302\357\336\036\262?\256\315x\233M\255\334?Eu\217\003O\210\253?\247\306>\252JS\304?w;\340\363\230\234\247?!i3\234\022\016r\277\330=> ZS\244\277\212<\n\361\362\"\272\277V\344d\271\356\365\311\277\352\032yJ\204j\314?\3253\364A\365\001\305?\231+u\301Rh\305\277\255\025\317\004\212\245\277\277\274\240\206l\271\201\320\277s@\2577\035\317\240?{\014,\324\203\000\324\277\1779\342\233\3712\313\277$*\370Z\023\020\323?\256cs\3448\221\270\277i\302x\353V\242\275?\333}m\274V\302\305\277\337:\031\342\270\000m?\322\361\370\344\246A\250\277\236t\311\261`\250\322?\200I\206z\302\232\272\277" + } + } + } +} +node { + name: "filter_type_1/matrix_3_0/read" + op: "Identity" + input: "filter_type_1/matrix_3_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_3_0" + } + } + } +} +node { + name: "filter_type_1/bias_3_0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 20 + } + } + tensor_content: "\276\231j\177\302\201\331\277Hu\234\301\211\010\357?\204\303\"\235Rc\300\277T\262H\242b\241\346\277\215\221\334k\023\253\325\277\230a\323\007\264|\301\277\202q\340\333\306\205\244?\014h\033R\373\016\244\277*?\337=\311\251\260\277^\240\302Po\334\001@\2035\376\247\367[\354?.]\031(@\255\363\277m\345hMp\013\322\277\307\351Y$\323\221\340?k\367\354\344\177\376\326\277f\352`|$b\345?\017M\031\226\205\346\347?\316\315\217\310y\346\321\277\004w\237bp\237\351?\nm+\016zG\354?" + } + } + } +} +node { + name: "filter_type_1/bias_3_0/read" + op: "Identity" + input: "filter_type_1/bias_3_0" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_3_0" + } + } + } +} +node { + name: "filter_type_1/MatMul_2" + op: "MatMul" + input: "filter_type_1/add_2" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_3" + op: "AddV2" + input: "filter_type_1/MatMul_2" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh_2" + op: "Tanh" + input: "filter_type_1/add_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_4/shape" + op: "Const" + 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\024\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_4" + op: "Reshape" + input: "filter_type_1/Tanh_2" + input: "filter_type_1/Reshape_4/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/concat_1/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_1/concat_1" + op: "ConcatV2" + input: "filter_type_1/add_2" + input: "filter_type_1/add_2" + input: "filter_type_1/concat_1/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/add_4" + op: "AddV2" + input: "filter_type_1/concat_1" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_5/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377.\000\000\000\024\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_5" + op: "Reshape" + input: "filter_type_1/add_4" + input: "filter_type_1/Reshape_5/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/Reshape_6/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377.\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_6" + op: "Reshape" + input: "filter_type_1/Slice" + input: "filter_type_1/Reshape_6/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/MatMul_3" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_1/Slice_2/begin" + op: "Const" + 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\270\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Slice_2/size" + op: "Const" + 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\377p\001\000\000" + } + } + } +} +node { + name: "filter_type_1/Slice_2" + op: "Slice" + input: "Reshape_9" + input: "filter_type_1/Slice_2/begin" + input: "filter_type_1/Slice_2/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_7/shape" + op: "Const" + 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\004\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_7" + op: "Reshape" + input: "filter_type_1/Slice_2" + input: "filter_type_1/Reshape_7/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/Slice_3/begin" + op: "Const" + 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: "filter_type_1/Slice_3/size" + op: "Const" + 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: "filter_type_1/Slice_3" + op: "Slice" + input: "filter_type_1/Reshape_7" + input: "filter_type_1/Slice_3/begin" + input: "filter_type_1/Slice_3/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_8/shape" + op: "Const" + 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: "filter_type_1/Reshape_8" + op: "Reshape" + input: "filter_type_1/Slice_3" + input: "filter_type_1/Reshape_8/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/matrix_1_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "\013\214\342\027\375w\337\277\325\336{zS\333\312\277\264V\013`\253\276\342\277\247\004(\257\366\371\326\277j\216\360\277:n\350\277" + } + } + } +} +node { + name: "filter_type_1/matrix_1_1/read" + op: "Identity" + input: "filter_type_1/matrix_1_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_1_1" + } + } + } +} +node { + name: "filter_type_1/bias_1_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 5 + } + } + tensor_content: "\303\026\245\237k\277\375?;\314WQ\007\\\361?\213\000v:A\327\347?6\t8{\267\245\371\2779y\274:+X\365\277" + } + } + } +} +node { + name: "filter_type_1/bias_1_1/read" + op: "Identity" + input: "filter_type_1/bias_1_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_1_1" + } + } + } +} +node { + name: "filter_type_1/MatMul_4" + op: "MatMul" + input: "filter_type_1/Reshape_8" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_5" + op: "AddV2" + input: "filter_type_1/MatMul_4" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh_3" + op: "Tanh" + input: "filter_type_1/add_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_9/shape" + op: "Const" + 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\005\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_9" + op: "Reshape" + input: "filter_type_1/Tanh_3" + input: "filter_type_1/Reshape_9/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/matrix_2_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 5 + } + dim { + size: 10 + } + } + tensor_content: "\2405,r\201\360\311\277\320\216|u\277\242\341\277\264W\217\337\273\252\271\277\244\021\353\360\376kM\277\r!`8p-\326\277\224T\021\357\247\036\265?B2\363}x\246\307\277\024N\022y7\250\322?\017AT\330\276-\277?\330G\\\330F\t\237?\0168f\320G=\273\277\337e\222d\276Q\333\277%>\364\253\316\276\325?t\311\\\323A\0136\277\003\030\234\331\301\265\303?\351\004\221Xf\251\334\277jO\244\0033f\271?\211\010\312\010\255E\342\277\261\227\277\347\216\327\267?\324\315\3204\364\017\305\277\3532L\007\266\355\266?\3007\237\300\020H\337?\017mGL\352\344\324\277\222\362\030y\302E\314\277\210\315\036\223\363Q\240\277\313\201\023)nE\313?\3121\243\007mV\336\277+\336\211\036\226\323\261?\324#\032&\355\345\305\277\341\245\347\002\363\217\312?v\317\207\024W<\306\277\362Y\276\311\372+\257?\257\205\252\252\221\345\247\277\026\201=\220\341\327\301\277\235\345+\242w\331\313\277N\274Q\220,g\307?\326\323\335\265\263-\262\277\310P\376~Xe\257\277\324[_\356\017\026\337?/\334oG\017j\302?k\032\006\3707Z\300?7\264\024\317\346\203\322?\233\204\201\320\004=\277\2772/%\213H\354\316?\250>\363\342\017\304\274?t\364\231\023c\177\257?\212_^2\346\204\277?\tR5{\364\370\263\277Rr\206=:\252\251?&\332\221\332Tw\323\277" + } + } + } +} +node { + name: "filter_type_1/matrix_2_1/read" + op: "Identity" + input: "filter_type_1/matrix_2_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_2_1" + } + } + } +} +node { + name: "filter_type_1/bias_2_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 10 + } + } + tensor_content: "\274D\221<5\027\325?\365\340\322\001Wq\352?\227\000.\002\254\256\200\277C-0\305\037\214\225?\250\204\355\t\220\030\363?\373\324h\010\335\032\262\277\263s\300\236\312\036\311\277\342\221\220\353k\316\352?=\372-\033\3244\363\277\010\245\276\370|\235\357\277" + } + } + } +} +node { + name: "filter_type_1/bias_2_1/read" + op: "Identity" + input: "filter_type_1/bias_2_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_2_1" + } + } + } +} +node { + name: "filter_type_1/MatMul_5" + op: "MatMul" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_6" + op: "AddV2" + input: "filter_type_1/MatMul_5" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh_4" + op: "Tanh" + input: "filter_type_1/add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_10/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_10" + op: "Reshape" + input: "filter_type_1/Tanh_4" + input: "filter_type_1/Reshape_10/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/concat_2/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_1/concat_2" + op: "ConcatV2" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/concat_2/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/add_7" + op: "AddV2" + input: "filter_type_1/concat_2" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/matrix_3_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 20 + } + } + tensor_content: "\314\0239\023K\037\265\277\022\210~\003\332\013\316?\007\256\265\313LF\274\277Y\t\345)7~\245?\001M\271\235\322\232\240?\252=\372\345\235P\271\277\221\261\366]\234\r\326\277@\177k\276`\213\304\277\225\323\003e?q\306\277&\354\316\250\177\013\305?\356\017\"\004\333\367\263\277g\255\2066\2162\306\277(\320\335\266ag\272\277\035\221v\002 \214\223?\037 \361J8\316z\277f\021\263\367`\373\275\277\261\270\324\217,x\253?\201\233\2645pe\313?AN\212;c\360\322\2772\361\311\276+\377\326?\377d\273\327IR\253?!\010tE\251\027\252\277w63:x\362\266\277Ot\327\233\211X\317\277\020\\E\315\250X\305\277\010;\252Vf\341\310\277\261UG\024\000\361\224\277{\2539-\257\275\312\277\364\271\346\207\221\036\306?\263\020\274\267\244\237\315\277s\273\300b\370\250\266\277\034\001\244\212\237\314\324\277e \2775\314\010\275?,\265\273$\'%\272?\305\033\266\334b#\236?\2430PK\361\346\304\277+rVm\340\007\275?\264\266)ix\252\245?m\'\306\371J\314\300\277575\tC\376x?J\204+X\264\010\266\277}_\204\335\321\237\306?\023\346Ksv\216\276?\316\022\244M\213E\301\277\327?\353w\223R\313?\220\3014+I\372\204\277\314w$h\255\002\310\277p\323\304\300\302\002\261?\240\316\304&b\301\320?\304\204\271/=\313\261\277T\263\363,\212\237\263\277\314\254\230\216\315s\263?\356\200p.\222\364\255\277,3\221\261\244!\271?\004I\034(\364d\261?\344\225\366\014\373P\321?\'!\311\233\030\326\273\277\270\222c#~\\\266?\034\311<\312\005\022\303?y\340ErD\023\263?R?\031\026\367\223\273?\000\227\264\253\035\360\332\277;\355\274$])\273?>pKk\010\205E?T\242(\227\225a\327\277\340\t\005\2573\256\313\277.\022c\206\322\253\325?\320\315\027\204DR\323?s\246\314\263\321\222\311\277\357\350[{\366x\332?\334\021\354v\311\244\261\277\3638\326\207\335_\265?\"\220i\362\2325\222\277\333\024/\357\320\224\266\277\230\355\361z\220\273\256?M\217\240\276\020B\252\277\302\227\352l\255\346\311?F\\\364A\245\311\327\277\035\014\256h\026\034\300?cx\300\005\306\247\336?\360\342\n]\242\331\325\277)jv\243\321\271\310\277\220\262N\332\227\354\304\277B\031\252\203\203\204\304\277\253\033\014\177\241\334\307?\317qi0\355$\262\277\277\363PC\035B\257\277\325\241_\000\340r\231\277\351\233\237M\242\377\327?\177_\016i\263X\267?Z\004\0258h \256?O\334\222 \215_\316?\211\207k\"Q\262\315?\013\322\3305_\001\315\2772\220\333X\t(\311?\367!$\r\234Q\326\277\252c\315\3126\031\263\277\343\210\n\251P<\274\277\265\333B\211\331\256\267\277\"Y\340\001\240\362\304\277\366\27265\213\271\251?\013=\323\362\265\203\307?\344\244\377\262\322@\316\277\032\307\215I\267\366\264?\025\036\377:\"\021\321\277\366\314\346a\277\201\340\277\340o\322T\321\372\245\277\313\243\322\242:\314\270\277\226\004\205+$V\333?\026bb\177\227t\267\277o\026\351\211\224\220\257\277\257n`\353\n~\254\277\227\375\331YND\214\277\216\233\032\026x\014\255?)\332\3608\244s\270\277\236\275\216%H\034\314\277Y\321?\321\3057\267\331\026\234\277\"\310Q\272\346\323\267?\021\310M3\315e\310?\236v3T\277\305z\277\220\341\234\356\0325\303\277\201\227\314\257\323\"\253?NX\233\323\037\330\277Di\360\207}1\246?\201\312v\304\037[\240\277\226\'W\213\233[\302\277z\332*-\213\355\302?\267\313q\377zF\321\277^\321\250\003\333\332\250\277l\204G\346{\204\311?R\304M.SB\306?\270\207\276\243L@\252?\266\031~\243\263\312\325\277\262\334\200\017M\034\273\277\216P\220\243l(\253\277\236V5\257\320\003\270?q\304Ql\254\311\321\277I\264\210\315\\}\326\277\367\332\307\032f\267\240?X\020\246\031=\027\326\277\241\311\032}\2105\323?<#\202X\273\370\234?\367\347\307\276\371Z\310?m\230\371]t,\303?\352{\'T\364O\232\277Jv0$\370\257\316?\315\371V\025\360\351\276?\343w\333\223\250B\335\277\032L\375n\317\241\322\277(\370$\236\277\243\260\277\235\220n\342\006\032\270?\376\004:U\"\321\244\277\004A\361bb\223\335\277\324\366\200\332\343\300\245\277F\007\221^\006J\262\277\242\371\177\273~\321\321?v\017\030\300K\367\210\277\233,\3558\216U\264\277\363\001E\316\352\350\312?\270\334\376D\345a\267?bD0\261ty\265?+I7\"M\251\317\277\365\343\317P\213`\311\277\202w\213\366\023+h\2772\2678\343\031\245\303?dF\365\300iJ\331?\376pP\256xK\312\277w[\351\374I\366\221?\333\260\311\312+;\245?\271\033\2272\317\232\237\277G$\224\376Z\245\262?z>\337J\362\"\303\277&\030N\241\347\367\275?\005\237\303\264\346\261\244?,\356\026\376\231\203\264\277\326\226\313y\033\203\323\277\271bt\206uL\326?\365\310*\203\320\363\302?Y^O{\244\344\313\277\300E\313\365\017\016\323?O\344\332(>\311\336\277\023\234G\022!|\266\277a+\261\017\240\330\252?]oh\312\334\222\327\277\250\030`k\005\342\233?\343\033\353G\036\010\252\277\372-\225/(\307}?1_\376\"\027\001\311?\3108\031\247u\316\312?\260E\371o\371\364\200?\223.\n\314j\216\272\277" + } + } + } +} +node { + name: "filter_type_1/matrix_3_1/read" + op: "Identity" + input: "filter_type_1/matrix_3_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/matrix_3_1" + } + } + } +} +node { + name: "filter_type_1/bias_3_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 1 + } + dim { + size: 20 + } + } + tensor_content: "j\t\326\260\252\034\353\277\203WH\271\262\341\320?8\322\330i\317S\352\277\013\355\317\261g\236\345?\030\205\221\251E{\350\277L\031\213]\014Os\277z\226\224\226\320\272\323?\210\244\214\302o\223\356?\031\037\302\303\001k\340?\350C\026\022T\034\327?R\234\375\177w&\356?\3176\330Z\372\016\370\277\034l{CXo\003@\254\346\210UI\276\001\300\304\264\261\302\204\t\347?\'\217\237 R\275\362?\266i\222\214\177~\326\277\334<\200\n\343\371\304\2770\311\255\014\261\220\325\277\202\345JX\215V\374?" + } + } + } +} +node { + name: "filter_type_1/bias_3_1/read" + op: "Identity" + input: "filter_type_1/bias_3_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@filter_type_1/bias_3_1" + } + } + } +} +node { + name: "filter_type_1/MatMul_6" + op: "MatMul" + input: "filter_type_1/add_7" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_8" + op: "AddV2" + input: "filter_type_1/MatMul_6" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Tanh_5" + op: "Tanh" + input: "filter_type_1/add_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_11/shape" + op: "Const" + 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\024\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_11" + op: "Reshape" + input: "filter_type_1/Tanh_5" + input: "filter_type_1/Reshape_11/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/concat_3/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "filter_type_1/concat_3" + op: "ConcatV2" + input: "filter_type_1/add_7" + input: "filter_type_1/add_7" + input: "filter_type_1/concat_3/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/add_9" + op: "AddV2" + input: "filter_type_1/concat_3" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Reshape_12/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\\\000\000\000\024\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_12" + op: "Reshape" + input: "filter_type_1/add_9" + input: "filter_type_1/Reshape_12/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/Reshape_13/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\\\000\000\000\004\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Reshape_13" + op: "Reshape" + input: "filter_type_1/Slice_2" + input: "filter_type_1/Reshape_13/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/MatMul_7" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_1/add_10" + op: "AddV2" + input: "filter_type_1/MatMul_3" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/mul/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 0.007246376811594203 + } + } + } +} +node { + name: "filter_type_1/mul" + op: "Mul" + input: "filter_type_1/add_10" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Slice_4/begin" + op: "Const" + 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: "filter_type_1/Slice_4/size" + op: "Const" + 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\377\377\377\377\020\000\000\000" + } + } + } +} +node { + name: "filter_type_1/Slice_4" + op: "Slice" + input: "filter_type_1/mul" + input: "filter_type_1/Slice_4/begin" + input: "filter_type_1/Slice_4/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/Slice_5/begin" + op: "Const" + 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: "filter_type_1/Slice_5/size" + op: "Const" + 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\003\000\000\000\377\377\377\377" + } + } + } +} +node { + name: "filter_type_1/Slice_5" + op: "Slice" + input: "filter_type_1/mul" + input: "filter_type_1/Slice_5/begin" + input: "filter_type_1/Slice_5/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "filter_type_1/transpose/perm" + op: "Const" + 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\001\000\000\000" + } + } + } +} +node { + name: "filter_type_1/transpose" + op: "Transpose" + input: "filter_type_1/Slice_5" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "filter_type_1/MatMul_8" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "filter_type_1/Reshape_14/shape" + op: "Const" + 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" + } + } + } +} +node { + name: "filter_type_1/Reshape_14" + op: "Reshape" + input: "filter_type_1/MatMul_8" + input: "filter_type_1/Reshape_14/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Shape_4" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_15/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_15/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_15/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_15" + op: "StridedSlice" + input: "Shape_4" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_16/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_16/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 4 + } + } + } +} +node { + name: "strided_slice_16/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_16" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_8/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 320 + } + } + } +} +node { + name: "mul_8" + op: "Mul" + input: "strided_slice_16" + input: "mul_8/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_11/shape" + op: "Pack" + input: "strided_slice_15" + input: "mul_8" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_11" + op: "Reshape" + input: "filter_type_1/Reshape_14" + input: "Reshape_11/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Shape_5" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_17/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_17/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_17/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_17" + op: "StridedSlice" + input: "Shape_5" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_18/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_18/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 4 + } + } + } +} +node { + name: "strided_slice_18/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_18" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_9/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 20 + } + } + } +} +node { + name: "mul_9" + op: "Mul" + input: "strided_slice_18" + input: "mul_9/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_10/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_10" + op: "Mul" + input: "mul_9" + input: "mul_10/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_12/shape" + op: "Pack" + input: "strided_slice_17" + input: "mul_10" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_12" + op: "Reshape" + input: "filter_type_1/transpose" + input: "Reshape_12/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "concat" + op: "ConcatV2" + input: "Reshape_7" + input: "Reshape_11" + input: "concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "concat_1/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "concat_1" + op: "ConcatV2" + input: "Reshape_8" + input: "Reshape_12" + input: "concat_1/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "o_descriptor" + op: "Identity" + input: "concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "o_rot_mat" + op: "Identity" + input: "concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "strided_slice_20/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_20/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_20/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_20" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_11/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 320 + } + } + } +} +node { + name: "mul_11" + op: "Mul" + input: "mul_11/x" + input: "strided_slice_20" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_13/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_13/shape" + op: "Pack" + input: "Reshape_13/shape/0" + input: "mul_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_13" + op: "Reshape" + input: "o_descriptor" + input: "Reshape_13/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_21/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_21/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_21/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_21" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_12/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_12" + op: "Mul" + input: "mul_12/x" + input: "strided_slice_21" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_14/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_14/shape" + op: "Pack" + input: "Reshape_14/shape/0" + input: "mul_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_14" + op: "Reshape" + input: "o_rot_mat" + input: "Reshape_14/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_22/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_22/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_22/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_22" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_13/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 320 + } + } + } +} +node { + name: "mul_13" + op: "Mul" + input: "strided_slice_22" + input: "mul_13/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Slice_2/begin" + op: "Const" + 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: "Slice_2/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice_2/size" + op: "Pack" + input: "Slice_2/size/0" + input: "mul_13" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_2" + op: "Slice" + input: "Reshape_13" + input: "Slice_2/begin" + input: "Slice_2/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_15/shape" + op: "Const" + 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" + } + } + } +} +node { + name: "Reshape_15" + op: "Reshape" + input: "Slice_2" + input: "Reshape_15/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_23/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_23/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_23/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_23" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_14/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 60 + } + } + } +} +node { + name: "mul_14" + op: "Mul" + input: "strided_slice_23" + input: "mul_14/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Slice_3/begin" + op: "Const" + 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: "Slice_3/size/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Slice_3/size" + op: "Pack" + input: "Slice_3/size/0" + input: "mul_14" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Slice_3" + op: "Slice" + input: "Reshape_14" + input: "Slice_3/begin" + input: "Slice_3/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_16/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\024\000\000\000\003\000\000\000" + } + } + } +} +node { + name: "Reshape_16" + op: "Reshape" + input: "Slice_3" + input: "Reshape_16/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_0_type_0/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 320 + } + dim { + size: 10 + } + } + tensor_content: "\376q\005\320h\005\241\277\023\014\333\307\'\r\232\277HY^\016C\305|?\332G\216\024Q\"g\277/w\326Wt\005\264?\022g\212C\215\005\207?7\333C\254m\367\245?\376k\003\230\354,\303\277\221yp:\360\323\240?(\023!\335\210\300w\277/\251\342\363.\212\263\277\373\321\253\202\311:\266\277as\006z\2324\220\277i\030\325\262v\014\303? \326\246\345\0068\263?\315\336\316\rv\255\247\277C\233\207ej\314\301\277^\371S\221`\357\302?\263]\315)\201\036|\277\310(X\204\251\247\276?\332\271c\217\027\202\211?%E\030:z\336\241?\\\203\347\250\201\354\257?\020z\376\373\232\340\225\277\0350\235\025\2774\253\277\261\034\2242\337\337\246?A\032)\000\036\032\242?\262\354\376YO[\305\277]\220:\327J\343\260\277\307@o\343\250x\213\2775\367/\241\034I\263\277\034\265\364\027d\212\234\277\375\027\354\265\363E\245?e%\321\360\002x\253\277\315k\246\334\214Q\262\277o\033%5)\275\220?\251\216\3217\237\343\266?\021\301\306\227\253U\243\277\350\361\024Ay\035\211\277\362\030\330\030\274\013\233\277\207X\213+h\376\260\277\r\261\303\364\033S\272?PN\n.\234\033\221\277\212H\214OW\"\221\277\3729\245\304\235\215\203?\025Z\301\260\324%X?\002\351\n\025U+\246\277\371\263m\244\370\241\254\277\035a\016\234Vhw?`\200\320\347\027S\265?H\270\357A\260e\257\277\374\257\327\270\005w\231\277?\317l7\230:\303?\242\371\213.\331\007e\277Q\365Nu\264r\304\2776\3453\204b\005\257?\234\246`[\210\332\240?@\0147\271II\263\277F\206Ep\352\014m\277gQ#\326\216\370\240?\327b\364h-\354\247?5\214\'\240C\024\241?\247\306\263`\234\023\217\216\256\277p\233u\270q \214?\211Di\355\351>\243\277\3436\265\231\356,\301?\217\016\201j\202*\232?\211j`N\2562\231?No\341Bw\236\224?\305\304\263\335\266/\263\277qb\014\032?\273\223?k\350\344\03698\246?\016\261$v\233\023\234\277\355Q\335#\210\267\274\277Lw\t\014\200(\260?\006m\227\"\036\024\204?\232\270\240\003+\314\263?\0220\017-T\314\227?0\216t\177\027\221\222?6F.\262\013}\264\277\322\255\344\377\255\201\266\277\303\014}\303\212J\305?\n\n\360\223\327K\267?\264\014:\213\360\231\241\277(\344\303\225\366\321\270?\357k\006t5\256\246?1dw}X\230n\277\t+\337\244;0\232\2770\364\023\237\237\'\204?ULg\022\225+\243\277&\230I6\010.\246\277\215\343 \004D\000\233\277\344\223\277\230\350\335\256?\r\363\321\020\007$\235?\367\2278nGM\253?\3600\303\272\301\022\275\277\334T];\371\024\257\277\306^\314\273\300F\260\277\327\224\224N\177\360\264?\373Sl\300N\375\220?\030\211\266\033\016\250\234\277?\222\253\272\346@\203\277\235\303\221\241\373\210\264?u\334\212\244\007T\300\277\3719\364\250\264\341\242\277\373\035B\315\310\264\273?\355\207\220]cR\241?r\366\241{\354#\216\277Z\210\177\251\244\027\227\277\241\215\301P_\320\265?\250\313\323\253\252\013\234\277uHF\030\026R\302\277`\t/\017\211r\261\2777\303\320/\265\330\237?6\2266_B\252\221\277m\210\317\360\341B\200\277\356\360\331\206\343{|?_#\331w\373\310\234\277\225\203\202\265\204\324\265?w\306\307\256\301\301\206\277\332\235\t\375\247\000\242?\302\341\\m\031R\256?\344\267-\257h\365\223?\312\003\254\202\r\tx\277\367\2442\341\317\216\224\277\001M\360&\364)T\277k\340\305g\370\212\247\277\200agC;q\224\277\373\034\001-\034)\264?\3637]*\260\200\221\277\n\364\177\006k\335\257\277\001\027\2601\307\372\250?\262\235<\035\221\347\261\277\007\317s%\244\031\265\277\307\3205\242\343\354\264\277\320\037|3\203D{?\224:s\203m\010\222?\362#\205\201W\321\257?LwCS\323\006\242\277W\257\314+\022\205\265?\360($^6\332\225\277X\001\274_[0\223?\334@\345\365\252\333\261?\035\251\305\315\200\371\260\277 \314\220\246^3s\277\275\010\025<8s\210\277\251*f+\032q\242\277wmN\335\347#\216\277\233\001\311\217\372\t\300?\036V\356K\242y\253?\016\263K\001t\346\273\277\321\325\214\233\2454\234?\345\274(p\233\346\217?)_\243\006wE\256\277\322\"\251\225\247`\267?\023\324\230\260t\210\237?#\262\026\331\016F]?\233\300\341\343\265\245\222?\314W\262\341\027\235V\2777oc&\'\353y\277\367\013-\016\035\230\275?$O\335\360\214%\207\277\013\342g}\311\257\306\277\211)\374\213\223\030\225\277\254\226\276\326\203\335\255?\376Q\262O\266\215\311?O\314\366\366\377\241\216\277\022Q\"\"*\274\230?\"\034-\0305|\303?\302\031\261\201\367H\227?n\251\311Y\3440\213\277=\272\335&\005\247\261\277\213\266\310\341\377%\244?I\246}\366V\300\244\277\223\300[9\366\351\224\277\\\357\213\025\345\r\242\2776\336\235\035ez\256\277di>R\t\270\242?\310\251K\210\\R\240?\216\023\301\217\303b\245?\223S\320?\363\032\243?\177b(YV\335\242\277\2764P\3444\r\302\277\355\3473\006KJ\274?A\276H\375e\263\255\277\0233\225\010\303\255\265?\275\202\371\t\273!\270\277\347\210f\246\031\034\262\277l\030<\364I8\241?Y\267?\274\236\245\246?\264\324\361&,o\253\277\026\r\216|\033#\237\277\341\255\016v\337\265\260\277\314\364\036\234\217\355\233\277B\001\267h\017J\204?\3001a\'\242?\301?c\211\304\307SP\243\277\235\035U\001\301Nz?Z\2324\036J<\274\277]R&\341g\355\251?\245n\374t\366\005\242\277:\031S\003\332u\265\277\026u\313a\037\025\250\2776\300r\272\304\261\233?\330\361\215\253\226\274\264?{\351\005i\026\257\246\277\372\177\002\367\364:\267\277\ns\"\340\030\207\251\277\354\020\314p\360\200\273\277\203\242\'\2515\351\261?\025\277\351Yk$\243?\272\200\310\357\216\301\261\277\312\2010\234\tO\226\277o>f\r\307\251\267?LE\356u\214X\241?\367C\206\2229e\207\277\242\013\360\027$\245\230?w\263\332\374\020W\251?\342\2276\201I\336\206\277?7,\016\230\334\256?Z\302\221\327\265\272\227?\225\263\277\344\206\265\271?!{\267\312B\217\203\277c\222\235UN\261\225?\244>\301\037\252Ku?\231\034\220\2757\243\244?\227\275w#\004\324\236\277\001\345\304\344p\237\251?;\n2\211\372!\224\277\362\r\230\310\020\231\236?t^^LZ\254\234\277\2141iX\200\375\220\277\010\364T\325Y\240\265\277A+\030\226\326\263\250?<\215\255\277\221\242\224\277\264\177-$\1773\241\277\276Z8\361w\350\223?zz\301X\314O\250\277\203|\020\247\270\013\265\277p\272\026T\361\220\275\2773\232\022Q<\031\263?y\376r\340_\006\225?\362\300k\313\276B\211\277C\006\021\006\244`\270?\317\007{4\334*\234\2778\025\3572F8\250\277\322%\231}\007}\273?\306t\013\247\264\r\256\277\236\342\034\\\305\"\245?\320L\270]\322;\260\277\264`\240\370\220hz\277(\251#|5\314\210?\034\337o\213^\206\240\277^\034l\325\242*\263?\207j<\010\203M\202\277\251\202\027\211R$\230\277\261A\006F;\r\241\277\220\025S\2530\266\231?yy\271\366\234\243\230\277B,\3468l\003\226\277!\245o\016\200\226\245\277\354\211\216\203\016$\225\2774\370\2138\263\220\264\277AG+\224\214\021\265?\223\275\"\316$\371c?k\224\323\353\250\273\253?\241\351\261[\332\341W\2771x\257j\304\007\245?V~\233\215\013_\276?F\035\205M\276|\252\277`\0107\016<\246\257\277S\373\304b\214K\236\277t\025\365{\215\304\241?\237\240\000\2264\300\201\277\200\375N^\337\371\226\277\0377\314\343\002\207\242?\246<\226\016\363rk\277\257\257\005f\361M\223\277\247\377\236AY\212\255\277\223\200\236\237L\356\224?\372\361^\263q\304\260?\313x\212\372\324C\260\277k\266\336\022a\004\275\277\230\305\353\365O!\251?&\001\024\302\273%\251\277L4\256\213\2719\213\277\002\222\2008\336\341\251\277\232*\353\206\257X,?\306\217\322\376\320\234\244?\373\335M\265\353\247\270?\322\321\263\205X\375\227\277\357#\327^\244\234\274\277{GR>\325\351\243\277\306`\324\315\223\262\303?\032\205\0346qC\240?@\357\212\374\362\303\257?\007O\252\003\217\246\242\2779\216r2V\035\227\277QQY\037E`\226\277\200o\001>\326\234\222\277\242^\006\314/U\263?\331|\315\317\203\003\250\277\342\350\340\260!\014p\277\001\222\200\302\2147\240?E\221\347O\034\227\246?\324Vj?\225\352\253\277zs\n\241\365)\273?/\306!\003\235\350\263?\330\247\313\026\321\260\270\277\251\363d\306\243\237\251?_Ne\211\004\023\260?;\023\250\257\202\017\250\277\317\345+\021%e\245\277\361U18\224-k?\264a\021\214\264q\241?C\375\276\310\032\335\252?\355\362\021\327\343\n\303\277\216\303\0320r\256\226?l\346\035=D\245\300?\354,R\247\242L\227\2779t\"Yb\207t? \237\007`B6\234?\327\354z\363\240\357\205?\353\312\016\362\001\310\254\2772N3\313\215KX?\227\262|O\324|\254\277[\305\004\262\331\027\246?\275\022A\203zaP?\266\326U\r\013h\304\277\253\315\000\010V\260\211?\201\272\231RHP[\277/\nu\340\241\343\244?aBp\177\021\037\207\277b\271\306\242\230k\266?\242O\021\025AL\270\277\307\242\242\346\026k\241?\223\036\261\222\tJ\241\277!\341{\343\317 \240\277%Gg\037\3632\265?\367~\0366#\222\234\277\010.b\207\216\265\261\277>M\371\347\275\300\242?_,Y\032M{\250?\364\027VG\322\323\221\277\376\004\362\337bu\304\277M_\231\337\237\352\264?R\314\\\020\372\235\253\2775\344?[\257\r\255\277\n\371<\317,vF\277\255\352\316\302c\211\217?\207\331\014kR\025\260\277@(\242\267\r\247\246\277\033\3113\204gvl\277\210\310\332\266\325\362\253\277\336a\277B\340c\272?\010\301\\\315\326f\242?\326w\212\'Fy\256\277\236r\017R\022O\235?\001R\317|\026\257\254?Ti\313\265 \251\277\332\244X\337\256\201\224?\314\352\nI\324\013\206\277\200\010\305\016\332B\264?\014\006b\277g-\301\277W\314\031\347\356e\265\277?\3546\313q\325\217\277\035\376\363\345DK\217?\336+\346\373\217m\261\277%\344\246\214M\333\204\277m<\037\371p\036\232\277\023\354\353\023.[\261\277\271iEh\346\367\233?\333\032Q~\262\276\266?\245\357\225\270\277\222\267\277\207\026\275\2058\305\241\277\344=)\003w\216\260\277\n6\271\203\255n\240\277\371Dh\006yM\227?D\032\341\354\336W\247\277\250\271-4Oy\263\277\311\341\260}\030\241\302?\\y\374n\3435\262\277h\313\201g\3454z?p\035q\343_\206\206?iy\022\317o\334\206?(\035lr\376\237\201?\013\031\005\201\322\305\224\277\025\016$\241c\370\222\277\027\302m\253\246+w\277\347\314F\360GH\262\277\020\244P yp\243?\222]2\206hh\241?s@\027\207\254\027\260\277\234\367\2029){\253\277\340\346\302k\214;\210\277\357\233\270\342\"\256\224\277\271T\226\276\310|\260?\'d&W\263\002\250\277\r^\221\350\237a\271?\262\331\031\323cO\237?\342\302\245\316H\234\211\277MU\353\200QH\257?\360\2265H\200vo\277u\231\316\234\000\205\263\277\340\034\245\327\244R\273\277\306\023\2775\223\237\247\277$\014\r\375kt\212?\252\200\033r\177\\\222\277a+\030.\240\036\210?\351q\312\300\200\210\227\277\222$\370*\001\353\242\277i\025\364\370m\035\203?\340\353\326\257PE\221?\004J\347k\241-\217\277\316\n\315\263\2372\234?\207F\237\\\275\351p\277\325~\327\372\250\362\261\277\207\374^&\266\253\247?\204\246M\340\006?\272?Q\226\000Mt\333\300\277\252\210\n\350\014\243\256\277\n\305)N\024\253\272?d;\'>\222\177\267?\3174\277%\366m\200?\212[\377\204\334\002\271\277\215\254^h\202\377\241\277p\232\2046\234\"\226?\274fa\262\233\276\261\277\350p\216\263\nF\302\277$(Z\331\024}q\277\267\347\'\334\322\300\232?\340:w0@O5?=[\3213\177\231\256?\277\277<\021r\\n?\322\300\201\321\365\200x\277\352\023\344?\017\316\272?\\\376\365\214\222\215\261\277\"I\277\273a\325\245\277\035-E\204k\361\227?\027\005\300W\014\0378\277\374\304K\'\020m\262\277\007.\tf\224\257\227?\340\352\246\267\233\005\232?\236\025\021\245|C\225?\017\240\r\031\241\205\247\277\373\354\371i[\345n?\027\3528v\275\006f\277\363(\006n\005\262\275\277\353 \233\210x\016r?\340\0169\344\337\370o\277\223fH\255\206\203\254\277\344i\227\006\272U\250\277\350\021\250\016h<\266?N}\261_a\356\243?\234_\366a:h\260\2771P\345\002\342\245\250\277E\250\n\266\007\022\243\277\235\030\025G\370G\220?r\002\230\273PX\273?\006\216=\344\341\371\250\277W\266\207#\327\001\250\277\016\333\2062\002\305\260?\252\203\217\253g@\242\277P\202Yc\257\016\311\277\026\333\330\201\317\344\206?\032\214\303\310T\351\251\277\312\333\226\303\322\267|?\327\250Y\203\361\260\243\277\006\237\2022\265\000\237?\204\354\304w\005\305s\277L\177\276\342\024B\262\277\344\237\214$\360\333\275?t\341\277\264\261\336\302?\255\232{\3053\310\216\277+\237\346\246q\351\212\277\225\237\256by\377\275?G\327W\226i\322\262\277\001P\247~\343w\260\277\362\244\342gN\341\226?W\2778l\010`\222\277\033\252r\310A\n|\277\314\2142\245\231\307\242?\254\003*\"8K\300\277\215\216\354\304\203j\303\277\2220\365<\016\225\212?X\000Xl4\005\254?q\016\315\252qJ\222\277\005t\211A\351\302\247\277\'\000\252w\236\245e\277\235N\353\265\303\226\245\277\037\002Q\277\302\351\300?\253u\032-\276\226\222?l\353\355D\203N\263\277 w\233G\365\223\237?*d\247\341\307 \252?c\262\225I>\353\224?\31699\300\270S\242?c9 \346P}\247\277yK\311\232z\t\216?O\237:\357l*\221?\344E=\264\200\r\224?;\250\021\r\275\263\220\277x\020\'s\024O\267?\273\302\236@\337\354\260\277i\372\264#\357G\203\277W\222\224\034\007\002\254?2&\264\330\234\254\246\277\243\357T\276\242Ie\277\374w\341eD\315\252?;Y\242\263\377\355\246\277J(T({\363b?Q#\252Ok-\251?<\365s\374\277\377\262?\220\007*h\216L\251\277\3661\316\3703\003\243\277\221\325)\357\250\317\300?\223g&\330\034C\261\220?\246\254B\310\367Mw?\220\377\036\270\014w\301?\227?\035\302s\317\255?1?t\276e\305\244\277u\316\232\311/\"j?\371\003[\257\332\252\202?\257\330\274n\237je?JU\244e\226k\267?k?%\322H0\301?\321E\232\235\2154r?\237\315\322\242\032QM\277\376q\271\272\330\266\226\277F\2525Y\222B\313?*\333V\330\311\253\267\277E\303\271^)\227\244?i\03570\2209\245?9\216\366\371\364\250`\277\355\030\251k\365M\264\277\372\346U\274Be\266?\216\361\376\021I\014p?Fy;\263\034K\243?^\351\001\276l\323\224\277C\206\224\033o\027\230?H\000\354\215\327|\261\277\2164|\215\235\277\242\277\353\270\017lJ\272\252?0\216>@G\200\226?\'5p\003\014\370~\2777\313\236\024A\203\211?\217\270X\007\027\017\263\277\177+9\365jF\272?\340IzZ1\266\026\277rY\217\036\000\356\256\277\033\010\245\224\353\264\256\277\232+d\326\026p\235\277r\0020\033\307\264\253?\255G\226\016&\243\216?\241\223\235&\340\033\275?T\355\267\355@\366\206\277\365\201\374\n\215\332\205\277V\300kR8\263\253\277\325\025\365Q\242\202\242?\224\214\300\261\317\224\253?\212\335\254\242\n\303\300\277\006\025\256\301\214\276\235\277\020\001\304\001\350\004\226\277r\232\333\305\262\361\264\277\r6\204\207S\321`\2776\342\256?T\262|TP\372\242\277\276\2605\262\244\274\211?=G\032\231\213\'\205\27771\252I\037m\265?P\354*\367G\235\276\277\351*\251\223\0362\260\277o\213\3258\2278\240?\305\t\013\341q\t\231?\234\032\335\360\340\226\240\277\207\277\261~\\\274\234\277;\000F\252\267c\220\277\336\257\0204\266\'\230\277\202b\357h\201b\253?\024\302k\274\374:\250?\345kw&\025\316\203?\254\347\014\262\301\327\272?\337\332\227\265\204|\243?\375s\203\227\004K\265\277u\254\350\273\236\301\245\277\214\353X\010e5\267?O\233Ow}\"\232?>\377d\"n\350\233\277\"\246h\241\373\361\223\277;\013\354\003FO\202?\\\311\274B\263\"\250\277\325\3753\240\350\261\251\277n\017\305\365\354\354{\277\014\253\212\002\245B\220?\341\361\367{\206\000\240?\2109\370\373\257&\275?\2026\343\177\025\274\275\277#\233g\003\027\361\250?\3454?\031\n\221x?\227\342#R\243nb?\257{\213\227\245\226\260\277ZZ\342J\357\027\265?*\2003\260x{\263?M\013*\002b\317\225\2777\203\305D\252Zo?\002#?\231i\334\251?\020V{\n\220\365\243?\353\220\300\313\177W\247\277\010\212k\013\177\244\251?\214M\351,\311=\177\277e\2357^p\253\261\277\214\2163\016\304p\217\277A\312g\214\237Q\261?\220\337\t\262x\321\247?\035|\200\"\353\305\207\277I\262\253\332\363\362\223?/:\014l\311\205\244?\314\255\353W\361\371\272\277\374\177\010`\353\265\224?L\250\210?\"\260\262\277\"87E\177\006\261?\017Z\247!X1\206?\366\206\342\321\246\215\262?\030\004\003\036G\322\241?\"\224\010/\375\356\221\277.\022\014\0242\212\267?\225\257\235rl\216\264\277i\353\005|H\242\241\277\214\301:\r\312\021y\277\317G\202\356\007\030\214?\3739\226y*\337\267\277\341\204\315\017\363{\245\277\240\2455w\222\214`?r}\246\020\244\276\271?v6\020\327\022\214\230\277_\315J\324g\001\257?\305\306E#6\021\257?k\021$\361\262\236\303\277\321]\315\\\376\220\260?\266)R\231]\260\221\277\342\350\230\315\360?\265\277\334`\203gW\306\210?\225\331\346O\313~\206\277\234\334=\305\262c\273\277\335O\370\021\001`\261\277\227\216\\i7\270\224\277h3\260\031r\351\252\277u#*WG[\243\277\302F\345\022\302W\251?\031\340\'\234\355S\256?\216\250\366\353\317\023}\277l\370AQ\241\024\243\277\\\tu,\212\260\242?\272\327w\306\377Q\243\277M\203\307\007\230;\263?+\237\215\323\254\203\267?~l\3406f,\244?\024\243_*\313$^\277(i8u\225<\234\277\243\303\261%\036\230\226?\247<\272\342\n@\245\277\016\271\216\261\022T\231\277R\320\203\260\002 \274?\010\207\370\361\203\350\242\277\244\026\255\344\tr\267?\004\361\320g\233\026\251?\010q\320HC\315\250?\233\312\214V\272\233p\277\331\266Q.\304\263\216? \252)\371\224c\302\277\320t\351d\356Y\243\277\032\316t\2525\217\201\277\034\342\207N\330\365\260\277\225\247\010\3025\004\211\277)l\271\223\036\331\223\277|\024\027\016\326Z\265?\335[v\313v\245\261\277?\300\275\024\335\313\301\277\330\321\014\302\034n\274?\201Y\221\361l~\211?\035\230\267\rr/\242?\262\240\247\335\314\241\261?\372t\037(\233e\242\277\263\254\300\276\254w\225\277\227\264\004\3052(\250?\2671\231\3443\014\243?;S\236<\213\217\213?p\352ef\316\346\260\277\262T!\211\006F}?\004\263\001\211^\273\244?\225v\204T\235}\232\277\004*\336\210LV\250?J\275\3709p\357\222?M\307=\016\321!\226?a}\001\347K[\232?\225\220\206d\204\035\277?m\315\242\200\341\207p\277?*\342\327H\r\265\277\033\377\027\355\311\031\261?\335\020N#\014D\243?$\022R3Fj\266\277\352\3513o\236\261\224\277\273\002\034\210#\343\267\277\304\023\226&\264\332\223\277\202\234\357\226\'d\272?6\210\377\277\n\334\270?\213O\231\201\272\324\231\277\376\343\324\275\274?\245\277\3141\267\334\354\237\270\277\253f\216\341a\311\273\277\036\311\\\221\354\304e\277}\372\003\311\206\275\224\277g\r\010\307\024)\250?\2620\226|\327}\230?A\262\330\317\217\277\224\277\236\316\367\253\005\336k\2778\024\r\225\300\036\201?\254\353\023\030\247\262\206?\341\016\254trT\226\277\337J!\300\270D\311\277x\320\014\365\276P\261?\303\201-\223r\035\224\277.\305\016J+[\300?k|\t\273\240\201\252\277\036\231\035\236\335\320\240?\n\244\315\214a\\\231\277\336\355oZ%=\263\277\262\325\2624\277D\302\277G\033\031\226D\256\242?\337\325\177s\002}\263\277#\240\250i-\342\224\277Ar\366\217\253\010\301?\344\266\231OO\272\263\277\253\223\334\222\202\377\256\277\214\313\246\006\254\225\255?)\037\242\"\255\232\266?\376h\362o\277\001\257\277\303\326!\030\201\374\301\277\033*J\016\341\306\214\277\377\354J\"\3545\255?\033g+\240Z\336\206?\336\003o\004\261\367\207?YY\212\007\"\342\255?J\376\253\352\226\231\255?\276\343\232)\270\002\210\277x\274\321\202\310\316\276?2\r\036\373h\342\265\277\252\005R?\026z\207\277\257\213\225Mv\241\273?5\"\366kG \215?\364n\316\022p\317\271\277\033\035\013\205\'\017\261?z\233\217\206\215h\273\277\22786b\271Jy?\353\206e \033\321\224\277\244\233\344G\3531\271?N\312\360\211\375\227\270?N\315\210\345\320\014\261?\337`\323\321\312^\222\277\310$\023\326~\250\241\277\225\2003K0o\264\277\311\000\3171\333I\235\2777\247\021T\231\017\256?\364\334S\266\204*\221?K\257,4_\267\244?\313&e\\\371\226\303?m/\225Q!Z\220?\345|\363\333q\353\235?a\347c\314\0132\245?\025-&1\305\341\277\277\370\245\222\362\237A\251?\001O\235u\334\307\244\277?k\271\030\005\251\260\277\245\366D\371\334+\266\27797\035\032\224M\210?\001&\330LW\213\235?\223U\231X\360n\264?\001\203y\362\203\\\242?%\0147\007]\006\223?\326\273\233\22346\277?\340\315\037\365j\240\253?|?\253\037\315y\253\007\247?\014\365\366`pl\241\277\016\026\314TL\354\251\277\022\253\016y\271\201\240?\t\347E\310\'5\273\277W\226g\203\276\310\232??\273\306|\n\340\257\277\275\214.\200&\300\230?M\t\360EX\333\254\277\001\240I\341\376+\245?\200V\030\245\216^\242\277\221\323\201I\226z\254\277L\220%CL\330\234\277\320\216\33068bc?r/2y\267z\240\277\340\275\375\373\337\341\247?\301\222\r\336UO\265\277\024\220\234#o\313\266?\334\tu[t\325~\277\224\2450#&\220\204?\tpo\255\332H\274?\215+KW|\261\202?\327\377\345Z\022\037\245\277\177\023\373\251{\032\240\277\343\273~\001J\'\272\277\320\304f\256\206A\277?\317:\261X\253&\277\277\014<\266\331\253I\232\277&\362\232\253t\254\303?T\257\337xD\220\265?\214B\205\334\225\013\207\277\274\272\232\026\272\301\243\277\0300\311\346)\316\230\277m%8g\361\373d?\327Ny\271\027\017\177?\030f\2679\347M\261?\033\334U\nm\227\205\277\256J9\3300\244\250\277\345\215\363.N\217x?C\345\271B!\213\271?X\250\206\276\262\030\253\277\270U\252\205jg\215\277\326\214$ \3218\305\277\277%\275A\362\272\257?\2601\275\347<0\253\277C\025\373O\366\013\210?Mi_\342\257\323\233\277\025\325\265\201\232\033\267?\354\226[\217\010G\222\277\024Z\263K\252\"\210\2772\204u\toY\245?\306\303x22P\270\277\214!\373ZC\213\254\277\006\350\037\000\020A\260\277p\211cXt\237\263\277\340\203@\332\201\303\264?yi^\312U\214\260?\306\353\274\300B\024\262?\315`H\203\214j\276\277\005H\222\340\303\336t\277\207\332$\307\224d\244?>\211d\247k\t\252\277e\270q\330\273\373\241\277FZ\267yg\034\243?j\275\242F3\353\234?\340\037\230\tV~\271\277\374\203\251J\205H\255\277=\027\256\310\0372\263\277v\354y\373\3300\305\277\312\020na\330\355\216\277,\300\350\324\313&u\277[\263ZoH{\260?|\356\010&\202\217\306\277J\365Oi\234\376v?\037\007\252\204{\355\251?A\303\177h\225\301\266?\007\236\343\324L\232\223\277L\336\347}\327&T\277\211\031@\017\262\013v?)>\250\253\231~U\277\274a\253\000xs\222?\363Br\274\352\373\211?\202-\007\230\003^\255?/7\2331\331x\300\277\350\3036\332\307\275z\277u\026\004\257\311\354\220\277\364\204\326\335<\030\250\277\016\272VD\345\033\222?1r\340\267\256o\244\277r^\271\325\305Nw\277\356\204\353?\001\223\214?\033\016P\212\254\227\222\277z\307\3030\330,\264\277\364\242@\033\036\'\207?\006\226pu\010\302\273?,$5t\234\'\261?\'\006\266|\347\231k\277\014\004\003\367\216,\257\277\322\364]\003z\271\257?\266\017\000\007\005*\247?\215\'\331\246\377\317\244?h\375\203X\346u\264\277\032\rR\342\026+\253\277iEQ\003\331\210\216\277\371\025\206\267\211er?\370B\374Z\274\027\242\277\005O\262\'\354\352\227?I\347\213 %\005\270\2772z\341\263\336Y\221?\334\327\243\3142\257\240?f\016\372\255j\237\207?\275&\205\'\003?\244\277\244\030\000\360\336\302\244\2777\216\314C\264\257\231\277\260W\276*\276-\245?\031\247\2239\021\250>\277QhKAa\301\267?4\246\036\035I\212\266\277$\034r\301\031\326\264\277\3750\304\272\212\177\272?\251\313\325\226\2552\251?\021\003\352%\201O\300\277\226\215\264CKy\271\277#\336>\200\240n\243\277au1\215\363`\222\277x)6\206\376\252\263\277\334[|\372\301\014\225?\253\031tw|\021j\277\277t\374\250\0350\204?\267\206\263\207\027\377\267\277x\352\315\342!\226\261?p\263\020\2240\216\205\277\013\275\277\372?\334\263?H%\0220K\023\266\277\371.\373/Lb\270\277\230\265x\234J)\200?\036\316Y\001H\327\256\277\374\261i\360\324\345\216\277\357e\230\265KF\254\277\253\374\374\240\256q\227?|\213\253J\224\241\262?6_\344\031\356\035\261\277V\0138f\271\247\232\277}\346\313\355\254N\243?\374\334m\303\035\230\231\277\"z\021\332Z\333\263?\031:\022\215K\336\221?\276X5\017\347*\223?\002\345\314\343\r\207\224\277\033\363\261o\000\220\272?\016G\223\3230\250\211\277\362L\036\373\r\217\250?V\320\316\333\017\305\265?R\361\354\211\203\273\241\277\0178\031O\0210\211?\305\351\374Q\304\001\214?y\006M:\274\021\247?\356\364\274\307J\222\257?\314\325\201\373q\341\247?\370c\254\207\244\315\255\277\214t\211\263\'&D?9\214\270\236\354\201\266?\333\371G\265,\220\246?\346\352\"i\2701\306\277\037\204\346>\301\357\231\277o}\343\356R|\236?\014\r\275\005\217\004%?\271\311OZ\227\225e\277Y\220i_\335:\276?\207%\031\274,\323\214?\236\366\030\230R:\255\277z\023\315F\225\331\216?\270\200B\376Y\271\260\277U\354%\205\320At\277E!\324\272\362?\223?U\305d\311\035\253\267?\021\256\372KW\263\250\277\330L\225\264e\224\203? \352\332x\234L\263?s.\003\247\333\320\241?\030\035A\243\216\tq\277\020\315\260\276.\224\275?\374-g\327\"\315\275?\263\234\204\025\360ik?\t\330\006\274X\344\244\277\244\331\257\340mb\273\277\335\2008[]\324\256?\371\032a\226\227\253\223?\220T\216Jb\002\266\277\222\277\352E\347\301\245\277\214\204w\354-\177\247?\005K!\316\214\213_\277iav\010\271\"\245?\300VPN`4\247?\334\212\317#`\224\264\277\351\212\305\263\273\276\207\277Ie\252\237lD\271\277\216\264\321\301\365F\265\277\246(\232\241\332\034\245?\024W8:F;\220\277\370\357\026n\350\002\212\277^(\"=\240)\245\277_h\202\337:\301\242?\211\274\216@pc\242?\202\332\035\036\373\303D? \275\313\024\014`\245\277\350\322\323;\267\276\277\277\210+!\372(A\261?|t\261^{\240\300?\010\357\241\306,\023\226\277\177\216\232\361\020q\234\277\304\'-n]\215\272?\242\355\006\325iu\263\277\334V\375\207\342\337\220?\326\263\326\031\321\332\240\2771\260\204\306\342\242E?\214An\177\007\244\255\277\013\371\361X\232\255\252?8Y\324\223\033^\257?\021D?\355\021\335\225\2772c\240\330\216V\256?\307\303j\360\301@\303?\242\026\316\224\'\232\240?,\333\030\214\306\363\224\277\032)\200\222W\303i?\263\275\027<\023\200\240\277\272C\356`\211\206\245\277B\307O\213\322\220\210?\276\242\203\232Vy\270?\310eAS\367\024\250\277\223\010\203\277\230P\274\277\246\nT\355\345C\275?6j[K\022\262\263{\241\256\277\007\334VP\355\n\255?\233x\324j\255\301\262?\017\277\350o\273I\222\277\000\273\021$X5\263?\003X-\303\307\346\247?\007\227\026\363[H\255\277\024\022\355\233\022\217\224?\024\372\2513\375q\252?V\227\302\254\321\262i?\353\263\214\203\r\033\242?\321\375\304\256\002\326\240?r\032F\324\303\226\252\277\207\305\tk\224sp\277\341!\234\361\334\204\246?\333i\336\024iC\222?\202\000\244\360\276T\264\277-\t\205\347$\004x?\353-\3776\205\t\247?\221\017\030B\014\234\263?\314+\373\224\025\364\262?5\2045\233\311t\210?\366\351\177\250\342\017\250?\223\371\270:A+\262\277wd,E\026)\203\277y\215c\t\232\312\234?\245\210.y\212e\260\277A\"\036!\316z~?\367\211\364\247?\005\256\277\222\247~_\245\244\224?\021\365G9:/\220\277\265Q\200x\217O\230\277\237\351#\301y\373\240?\375\232k,\274\365\227\277\016\025b|\274\377\265\277\3236\3360\261\037\240\277\223Si\247l>\261?\353x\206\032Q\360\215?7*o\331@\217\266\277\371*\r*\325\310\203\277Y\365^\\\371m\236?mu\362\375\026\017\243?\0303Y\311\017\030\210\277\214\277\"X cx?\310\267T\376\2511\240\277\244\256\321y\3452e?\021\203\331\326\034\312\276\277uxi\322:\201\224?h\362\235\034(\203\205?\030\350\236\307\325xn\277\231K\267m8U/\277>:\2240U\214\227?X\371\255\270\300\324\231?\374\013t$\026\301z\277\332\240\016\250\270\010\232\277u\257\017\260\330\356\271?o~\341O\352\214\251\277$R~\031\326\210\264\277\260\357{\262\323w|\277\032\277k(*-d?\270\3656Fm\346\234?\330kC8\206\244\301?\357Xr:J\256\257\277%\226\244\032PS\270\277Re\211\034\345\300\256?(\026\200\351\245\307\227?\257\224\356\273g\234\226\277\332T\230\021i\364\262?\313V\2231\200\334\256\277\216\021\252@2\266\263?\264CG\246\030\327\236\277\374\317N\266YK\262?!\321\254{\325\324\236\277 I\233@\315\001\272?_\263U0?\030\226?\240A\376\331\335\024\257?\255\262j2B\215\235?\212\313-w\321\304\242?p\316\336\026h5\262\277S*\227\357\277\"\221?a\007\341N\232\214\214?\201\017{:)8\240\2776G\375\"\214\016\245\277`H\237)l\202\260?\340\307\305)\035\375\217?\345\213\305r\243 \230\277\037\026\"~\030O\264?\217\330\026\364v\351\227?\261\210\276\346\363E\263\277\203\275Q+\223\272\270\277\225q\264\211\n\233s\277\362\302kn\252\021}?R\020\360\373:\264\224\277 \342\343\242Lf\250\277\212.\224eC\027\223\277\026\277*\001\321\210\266?G2\241\240\035\030\255\277\211N\030\324\220\023\224?\023\313\215\206\311>\275\277iy;\312e3\274?\021ca\255a\333\261?\230\023\340\356\314x\265?\013\336\206\223\r\037\262\277C;\210o\367\267\272\277X\006\245~\277p\271?\313\370\256\017\354Q\241?\310\275\224b\301\245\241?sQ\350\335\263+\230?&\025\026\314V\324\244\2772gK\252\324\262\245?\202\376\030N\366)\277?ikvi\361\333\256?\325\230\226\204c\025\267\277\262h\252\351\211F\206?\037a\327\372I\305\255?\232%A\334n\014\311?\364\206\213\251\222\331}?\205\003\367<)\n\216\277\226C\2663T\351\250?\214A]\207\\\204\211?\322\\\252\267R\026\242?\352Q\276!\364\362\262?\352\370\237!\203\360\256\277,\336%%Km\243\277\341\325{<\302&\177\277\373g\365\244cm\235\277\276Mz8N\245\275\277\003\'\177B\225`\234?\332\220\3647h\255\205?\260\030\204\244yp\275\277\001\240\005m\323\345\244?lF\334\321\265\032\222\277\034\031Vs{y\243?\274U\323\260g\373\222?\270\031\242\231\177\t\301\277vq-\267M\375\206\277\257\037\262\002oC\260?\016\007\212\207\243\303\252?2p\277\376\217\030\246\277\036\307NS\331\327\273??\324\207\201j\320\241?\247\335\240lM\330A?J\310\000\365C\024\226\277\312\270\3111:\361\260\277\2171\254s\232\266\252\277~\014>w\345Ux\277SF\r\363\314\265\223\277\356\323\216H\035\300\235\277`\344\200\263\346q\234\277\371\333\330\331\016;\242?7:\377\220\307\004\213?\323=\351\366l\275\307?+\315#\232P3\247\277\212\242T\n5\247\244\277\202\241\351\340rX\211?\020a\363>\306\\\254\277\035\265\031\010\322\t\201\277\360>\t\251+/\274\277(\252\\q)\020\232?\224\247\3357\243n\230\277\032\357\002@,\351\202\277\266\210\225\021R\336\257?\214\365!\205\343\335\244?\255\361)\332o\000\261\277\272\275\201\331\302\336\236? \235\036\224\273\320\263?k\304\240\347\201\000\204?\367\242\0220S?\240?$\274\245\333h\200\245\277\217l7\364\300+\203?\275:\270J\0242\260\277\205\257u\335Y\273\245?y?LY\220\255\235?\241z\001\020*X\265\277H\237\301[\"\335\264\277\271s\002^J.\206?\361\t\031\342X\325\274\277\327~c\026_\370v?\202\366\331\006t\355\215?\215r=tt\302\257?\245P\345\001c\244q?\312\204\267\006\227W\261\277VW\026\2721\t\273\277.#\232-1\320\272\277b\272\237\265\306v~?X\034\260\321\215,\265?\245h\3359\336[\251\277<\210\350\273F]\307?\217\226\371C\206p\273\277D\024\340\240m\263\260?~o\320\213\"\301\234\277\363\303\327\267g\250\276\277\377\242\340<\361w\253?\020\016\351-hx\250?E,\277_\201C|\277.\342\224\373Ub\240\277\355\2320P\277\224\255?R+\251U\343\365\230?u\273\177\231\341\014\261?\217K\375\214\016\251\260?C\222\337\364\'\220\244\277sF\244\315\240\247\270?\301\3613i\377|z?\243\3779\332\337`x?\277a\306\035\336\020\263?\177\362\215\024\323L\261?{\265xy\016<\223\277\306\344\250h\257\021\277\277\325\022h\330{\203\301\277b\336\217o\321\336\262?\021\007?\255\322\263\230?\266 ?)\333B\262?\027\353\240y\216\005\234?\327\266\357\231\316g\301\277\236Am0\006\363\220\277\360\347\327\2428K\264?\255\325\343\332\272\304\237\277s\327O\245\003y\253?wLQ\217(|\246\277\325\335\t\2731\213\245?\271\357\271\204\n(\251?U\247\241\372J\246\233?\0031\305\365}=\262?\215\001H`\222\265\241?\244\355\242\330\335\036Z\277\274\032\356X\310\302\247?\022P\207\341\246\373\224?\223\013\210\231\367\364\256\277\257\006\350\245\027\335\251?Z=\226F\227\026\270?\017.\207m\037U\253?#\337\027\303;\031\252\277I\224\271\2354_\245?\215\007\217\320v\355i\277\034\300\n\250X\216\256\2770\376\375\177\021\242\277?H\247\274\217\201\266\266?\215\213\024\341~gt?A\025~r\362\017\277\277J\214\013\371\212\231\220?+\022\371^B8\265?\203\343\200\017]\203\277\277J\327fo\233\323\204?\333;AwY=\267?\235\244\333\250\'P\230\277B\032\020\236j\277\177\277\3136oP\214/\267?\245\225\235\202K\215\260?\202\213\244\351\274\200\262\277\025\273C\371\371 m\277\000\233j\253\002C\267\277\217 |\031\206\221\226?Br;i[\276\256\277\007\330;\333V\320\271\277C\0059\024\263)\262?\222LmNu\262\177?\tb[\331\005\t\265\277\034\366\177\344\360\304\222?\334B\035\311\2006\271?\340\315T\304\350\247\210?\252\007d\363\335\207\237\277\023\223b\273%3\264?\347\025\272KO\311\261\277\232\036\232\326\234x\241\277\334a\205(\332W\222?%L\355\277\2351\266\277\016\352r+\271T\264\277?\343\323\352\205\262\201?\243\252\\>X\301\233\2776[\021\207l6\273\277\302VG\337\211J\217?\235\377Q>-\242\301?\303qM!c\r\267?w\262d\367\353\212\230\277\320\201\202;W\272\234?\026\344=&\022K\255?\261\274\023\307\300\017\265\277\251\r^\357\026\032t\2778\341u\226\200:\264?\370\315\252f\212\234\210?3\001\323i\357\014\254?\241\244\360\025\036\335\246?\356\023T\373\n\343\263\277\373&O\205wtc?Z]?+\207\373\264?\177\355=]\345\302\254?\001\020\230\233\016\220\241?\345I\330\255\332\254\273\277\204\336\245o\304A\267\277\261\242\233\312b\333j\277sx\237lZkt\277`\213\010\354\322[\241\277\243\200u\024\213y\256?%c\234i\311\377\265\277f\357\0005TR\217?s\003tu[\263\271\277\2758\213\247\213Ok\277\021\224\022e\203\022\200\277\271g\223\317\213o\240\2771\021{\306\201a\231\277}\335\316W}L\262?J\\\364\342\200\003\254?\223*s\216h\225\261\277\2303\210\326\353\004\252\277L\351\t\020T\242\262?ES\222\350mV\275?\252D\356\207\035\003\233\277\376\330\304\331\272\226\265\277\0032\254we\361\211\277\242=L\3645\357\243\277\025\233\315\353\343T\262\277\3104+\245\216\201\304?\245;cQw\302\237?\2415H2\272\247\222\277s\220\250\014AF\271?@^2^?5\244?$>\247,n\232\253\277F\304\223\337\227S\240\277\212\342Ec\366\311\222\277O,\202\024\336\030\210?o\212\363\365\320\375\222\277\266\357k\364\262\230\207?1Y\006x\324\254\253\277\315\306f+\240O\224\277\333\232\213\026]$\233\277\227t\242\265\310z\300?\204v\037\224\3439\227\277\242H#\362X\323\300?W\207\211\257\275\222\244\277\360=\016w\025}\246?\324\260Ho\016\005\242\277>\013_n+S\230\277\003\272:\202\2659\251\277s\272\016y\014\255\301\277C\333!Z\201Q\214\277>\220\213K\253q\264?7_\276S\353\360\220\277Q0\027\314\235v\211\277\272\315/\230\360\312\264\277\337\252GB,\323\250\277(h\367o\277\273\270\277\346\005\014!\031W\305?#\316\227\352\375\023\231\277\2207\0021C\234\225\277\250\002\201\353\331\326\257?6`\030poS\262?R\355]\214\207\263\262\277\027\254\216\235\226\007\266\277\245}\363\371\005B\274?\254R\211\301\367\037\263? a\323\234\341\242\240\277\257\342d\017\361\344\244\277\325f\212\355\246\202\262?-\007h\016\356(\245\277\rf\213\244\264K\271\277_\024v\256Q\223\230?wAW_\007\237\244?\377\257\311\251\327l\224\277y0\031\271Df\246?\377/\230E\222\367\250?\272\013\276\346\020$\222\277>\321\364}\254\030\264?\325\321V\371Ge\273\277C\364\225\024s,\254?!\204i\003\350\374\265?<\264\325Dn\274\221?_\225\236\337\316\215\257\277\200\262w\322\331s\242\277C\"\300+a|\260?\361 \003\254\224\263\224?=\353\315\2304d\273\277d\215 *\310\367\223\277\006Y2\016\362f\265?Q\266,\230\270\204\266\277\232R\220\331\016\214\246?B\327\367\343\356\333\260?%\3560\320At\301\277\2751#\216\271\330\254\277u\262B\265\rO\247\277\346\243\2616}\013\264?d\255\037\320\242\356\240?\26341)\250L\247?P\307\305\225\304\217\261?j\356\340\315\227\177#?\240\311\310\017\225N\263?\313\370\034\340\003\034\256?%|\225j\014\033\272\277\033pQvD\336\271?\206\027\273\250xn\252?scm\033\255\023\246\277ke\007\347\221\212q\277\231-\263\215\271\362\231?\351\005g|\371t\225\277\321\311a\366\322\272\220\277$\346\245\261\301,\265\277M\264dX\031y\225\277RTO\255\016[\236\277\331\t\257U\035\340\225\277c\353P\250B$\255?I?E\331}h\256?\327\254\261\352D\276\202\277\362hL\206\005\210\251?\231k\372@*zS?\240,o\233\320)\260\277\215t\303TW\273\243?\r\305\320x\254\016\250\277\022\271\343\334\306\306\260\277\312\351+d\006\333\257\277J\353\363y\237\t\263?\332\330\235)\025\255\260?\342\335\351\226\2536\210?\246\336\354FQ\305\276?D1b\234QJ\223\277\\_\035\365\207\307\267\277\013\307\225 \030\354\242?y\'TbB\004\271\277\346\251\030\353\312\030\221\2776l\242\226K\206\253?\261]T\013\014\246\200?\237\311\245\310\371\260\224\277T\212l;\334\333\247?\263\023\021P\315\342\244\277\207w\0178B4s?V\337\025\225\016\374\242\277\034\273\254wG7\243?\363h\027\272p\323\261?\216D\343Y3\276\231\277$I\363\230+\305\265?5\205\020\307\353%b?F\205\022l\364\233\260?\211V\303\244\224\006\257\277\246\010q\032:\307\232\277\231\220\340\277\340\263\242?u\266\317\325\264\346\227?\312\305x}ia\246?`t\3501\234\277\265?\325T\264<\222\217\235?\320-\231\320\313\276\260\277^\205\027\360{\362\261\277\034\374\037r,>\304\277\n\020RMCB\261\277TGb%[\236\267?\010\014\227\214K\022\253?U]\364\255m\373\223\277\370M\262\272\013{\214\277r#\346\256x\211\260\277\013Pcb\363\254\301\2771C\351\336\344V\243\277@<\364\022\217\233\230\277\260\204\370\007\240\336\270\277\020\304\027\217e\020\254?\212A\333v0\255\277\277\240H\364\213\316\215\271\2772\256\201\362^\231\263?22r\275\264\320\232?\013\036y\2601\001\247\277MO\253\306\354F\267?-O\274\177\345\355o?]-\272\234JW\241\277j7Nm\237\233\243\277\"\245\321q*\311\267?\370y\337\314X\304\253?\334\267\215;\216,k\277BP`\347\210\340\233\277\r[P[x\313\267?\360_\260+\300$\241?\272\316\361+\333;\255\277\321#\340\234\361\227\227\277g\023lZ1p\265\277\023\346\344\270;\006\245\277\204\224]\222/\304\267?\240\305.?\316!\203?\247g,y\252g\302\277\037\251\377\027Y\364\244?D\372\241\344\272|\230?\204#;\235\205\200\246?\366\217\372\323V,\267\277\245e|\205\230\365\234\277U\344M<\236N\230?G\313\351\021\207\222\245?\327\345e\340\223\027\262\277\037\331.\342\021\242[?\021Oz\016\231\177\227\277s\343Z\010\215k\207?\266\'\036\013\n\207\301?C|\355\3606\205\265\277\335\020s\037\352\310\264\277\236UE\2673@\300?\317\300\020\264\363\354\232\277Bk\255\2269\032\237\277g\325\365\223!\201\203\277\336CR3%P\265\277\006J\266\260\306\t\227?(\244I,XY\247?T\327Eg\n\355\252\2777\260\n\321\177\262\202?\034\031\254\204h\336\273\277MU\007\320\023\334\242\277\376\030\200Z\013\033\304?\305?a\261\277\265&\314\254\267\351\233?\031\323\r\275\344\007\246\277<\210f\346\243-\241\277\316\230\370Q\374\220t?Pe\243}ps\276?\024f\002\252\354\212\257\277`\264@\363\216\342\300?e\347\230\314\223*\260?\371K\227\213z\026\242\277[\367\001\375 \275\272\277\026\215\316:zI\260?\'h\021q\232\035\275\277\034\363\246\271\332T\271\277s\202\317\232\206\365\302?Y\303\245\362B\272\222?\220\033:\351\377\331\221\277U\335^\327{\010\221?\327\321\275\257\327\376\212?=f@\311-\ts\277C\310\264\245\340y\267\277\243B\307\253\"\274\276\277-\266\353\272\277\024\323\177L#\301\260\277/\315H\233\265\277\014\254\223\230$\277\237?}\rj_\037\000\271?E1\300BL!\251?\223\337Ve\374G\255\277\231\334@,\024L\244?\250\343/\204P\340\233?:\253E\312M\310\304\277\303\227\030\257\250u\267?K]c\025\030u|\277\213\316\320\033Vvs\277c\265duxy\264\277\203\276\272\341\361I\241?\204\212\250 V\231\247?\303|\314\3605E\241?\306\375\345\252\243s\221\277\032\343T\250\357\272\233\277\034\021Ai\265\014\265?\245\003\361\330\321=\222\277\222\350\211si\320\225?N6\000\205X\016\241\277f~Mp\223\215\235?\253\026\371@\3340\256?\242\022\224\215\006\335\277\277+\353\225\353\377\241\230\277\335\210\262\277\321\014\245?\177\361u\013\016,\262?h\251Y\351\355f\247\277\355I~p\2266\265\277\2651\035(=\247\246\277\275\321\007\223k\253\255?KN*\2363\374\240?\210:\276\323\374O\220\277:]\021\336\350)\204?\363\264\213\231b\016\217\277\315\031\t\264\213\334\300?\252~\213=!b\300\277\274\306\2459\026\017\223?\310\255A\231;\341\234?&\021\022c\347(\225?\r\303:y\222\341\253?q\300\007\036\327\212w?\031\202m\340\305(\277?\237\376g\207\364\006\253?o8m\333\215*\260\277\334\020\266\277/\352\222?$\377mC\253\375\241?\234\304b\026\355\013\246\277gk\022\270\367\026\250\277\r\240w\254@\236]\277>z\252\367q\372\271\277\212\341x&\235.\254\277\026\201\303V\356\346\262?\343\312w\243;=w\277A/\227\016\017\034\236?E\250\235\231&1\267?O\361\264(\273o\271?\003l#\303\205\323\260\277\346UP\"\323L\240\277\250+\036#\266X\252?1h\211\006\231\240n\277Y\274\361\365#\376\213\277\"\313kEW\242\257\024\242\277<\211\014^\265\361\224?\331f\254\207\233x\262?\237\032\351\370\345\022\243?\266\004|\r\301\212\262\277\r\370\234\213\'^\263\277`\322\257\033vj\274?e,\321~\233u\264?\0252!\255\260m\245\2772\300\370$\035=\240?\006810H\325\224?\335\364\216\037HW\300?\006/\262\370\246\\5?wE\276\204\346\026\221?[\0072aq\021\211\277\264\234\236C]z\227\277\202\226H\003\010n\301\277!\352\347\340\360T\255?\266{\213%\336+\265\277\333\024\212\241WZ\254\277\024#V\007\021\222\250?W\004\242\221C\235\246\277\372:Uz\321\021\261?\303\364\363\254\214R\247\277\206\237\261O\0365\221?7gc\200\273f\264\277dbv\225\301\214\216\277\202C\224\333\225)\274?\002\036\372h\373w\217?\355]\246\224y\224\217?\363\204M\317\336\323\264?\267\247\243\2142in\277\251\2230.\262q\206\2774>\370+e%\210?\233\274d\022\310\250\230?\\\003_q\232Y\267?\313\003\230y\244\033\244\277\333\204\214\022\367\303\261\277m\225\016<\017\214\262?M\335\000=\300\251\245\277Bs\t\300n\214b\277\031bh\010\343\021\222?\267\305\272\261\311\200\274\277\326\207\375*b\272\220\277S\301\372\3249\031\224?\360\346gp\277\000o?;\343\327\214=(\262\277\2669=\261\267\272\304?U\232\231\306\213m\243\277\0244\035[2\326\220\277a\204z\261D\010\242?\236\2219)\251\037\266?\306o\242?\200\"\263\2775{\347[\223\230\242\277\350\202\234s[\347\201?\243g\334\322\233\021\217\277\014\007\343\240\026\215\242?\246W\314qN\206\240\277\017@\254W\346 \261?Gli\0164\013\240?\232\325\271\315\365Y\242\277\2444\252%\264%\256\277v8,\272\257\213\265?\222\363\rm\031\010\223\277\360\"\312\213/c\253\277=\235\362;\262b\220?\304\207b\324\344~c?\356\337y\3525\360\271?\024(\373\010?\235\221\277\237\202\204_\325\301\225\277\374\035C\347Nv\243?\020?\276g\270\322\273?b\241\001\302\247\300\263\277\335\013\t\nZd\255\277\303/\177\264K\347\230?\374\275\255\021\257\024\241\277\363\335\356b\265\033\251\277\026df\361\361\223\256?\276\346\367q\253\361\206\277\214\364\031xI\333\221?\031]\nq\335\026\300?1\310\252\372\022\027\256?\253<\326\031\262\035\224?I\270*\204\344-\250?\377\n\367\255\025\026\205?\033\310\323\220\352\364\264\277#\246\367\315P>\261\277\203\250\306\01046\240\277\033\216A&\321\326\251\277\264\206\212\250 o\253\277\300L\364\344\207\023\242?\203\353\320\033\341Z\304?\335\332\2226\345\202??\351\212\013}w\n\212?\n\325\0243ZF\276?\276\375\253\377\004\255\270\277\203\261\217\201\305i\222\277$\341\363\0105P\241?;!\314\205\001\302\271? \202\020\206J\205\262\277\332\232z4\371b\243?.\350\366e\326T\246?\315\200\032\276\344\353\257\277\020z\250\241c\305\261\277\336\212\314\352\227zv\277{7\363\274\261\262\277F\177\354\250R\312\302\277\263[C\207\203 \256\277\312\356g\224\276\311\257?\230\273\220\341\r\332\264?B\204\304\001\031\362\232?\022}\203\362\236o\231\277\312\341\372\233s\325\241?1iB\360\026\254\277?\250\320\247\224\020d\261\277l\226\344\203z\370\245?I\343\035A\242\231x?b\t\217\352\n\002g\277l\215\261\320\342\341\206?\013\364\017\341a\327\242\277\327\273\230v\203D\264?\255\3530\303;[\235?\243\256j\025#U\225?1\340I\324n\331\245\277\230\361\204\311\372+\266?8\022y\276}%\211\277M\225\202\341\362\345\233?\000z`L\231\022\240\277t\302\003\272\247\002\264\277\275\373\251\0264\324\250?\347\344\032\276\027\242\240?\243L-\316J\350\243\277\033\\\234\370\243G\272?\224@\303\311\331.W\277\206Ew\235\307\237\204?%\2513\03318\231?\n\253\201\302 x\266\277Org\372\214z\274?\005 T&m\377\242?H\253O\206\363\037\230\277Oz?\205\235\357\276\277\013~+u\036\"\272\277\321\004z\231\216\375\266?\344\036\262~\211\226\247?\t\270y\347\004\256\203\277\305\315\005\3164\202\230?\023-K\013\336\027\273\2777\257\366>\211Ev\277\314\323v\0065\220\202?\340&+\031\302\232g\277\264\241z\372\357\221\277\277\023\320qn\363\366\226\277\310\257\337\205\256T\251\277&\355^\r\301\341\250?r\232\n\203\324\376\252\277\231klQ\225F\254\277\267\370#\2459\325\244?\361\025\025\304\271\242\302\277\272\2778\257\226o\260\277f\007\000\030\224\250\212?tw\355\222\264\207\260?\027\312\320\236\250\026\241?=\363\267&\3548\271?\177\256\021\253\\\032\267?\317\313\252!q\010\303\277s\261\247\220\246\312\221\277\006\033\tD~6\265?K\315\267Zs\260\260\277\360EN>jE\237\277\352\264\370G\301\261\247?O\275l]\361\307\245\277-A\201\327\304\357\227\277\320\005D:c6\261?\t\347\tpS\021\220?\177\351NR\373 \270\277\356b\203Y\252b\256?\033&\200\261I*\242?_\215\352\'\2771\206?\035\252y \277\224\227?\212\023\212\312\367\344\202\277\215\312\007\227\252-a\277\0274\351y\327\271\246\277_\212\203\005d\240\251\277\021i\327\255\311|\225\277E#\346\241\355\304\275?\314\264\335\275a\206\247?M<\241;\234\233\234?#:\362v3\245\223?r\307\235n\007`\211\277\253\367\316a\216i\276?\3070\023\211\225$\207?8\346\230\003\356\320\236\277P\354\023\3039S\301?\370h\303`\232\255w\277\357\370p1\267\230\271\277\220)UY\0005{\277\t\364=\266\331\235\201\277\255\240\316\251\375\313\276\277\252I\225.]\376\r?\250 \375\260\222\322\262?0\315\361=-\305\262\277\207ur\010\305$\271\277z\315\"\376=\037\216?\006\211\250\243\352q\241?\362ZKn%#\240?G\017E%\374\204I\277\301\303@{\016O\244?\277\336h\230\212Z\201?\034\251\010\263\316P\267?\250\226F>\376\310\260?w\341\332}9\340\232?Y\223\241\2230O\266\277\024e\364c\005\250\234?\317\256\303C\276K\221\277\255\027\262E\266\243\252?Y\245\226\007\026\350\265\277\321TJ\321\276T\260\277\250I\266\016\250c\254\277\371\006\2762h\304\257?\006\330\037/}\'\300?\265_\361E\204\373O?G45\311*\251v\277\321\311\002\014\327 \244?\330x\362\017\r\336\251?d\272\331\340h\266\267\277{c\223A\351\333\257\277u\3430$\207a\274?N\361\302\333\253\025\242\277[0\010\262\013\263\237?\001R+\317-\t\243\277.I\034\370*\220\225?\364\356\034\222\231#o?Z\272\230xNo\266?\241\n4\201\315\343\234\277\366\316{h\031U\201?\343\353\035o\355\340\233\277\377\024w\200-/\242\277\200Y}\347& r?\024\327\265\375\201k\257\277\205\370:\372\3761\240\277\010\371\232\270\216\255\253\2770\346,\277\343\257\261\277\354\364\350\017\225i\273\277+\236\240w\202\213\246\277\362\373\217J\177\320\236\277\275\303)\374\\\003\260?\002X\330\266\032\3464\277\344\362\025\020\2447\201\277\017o\357\260\313\233\253\277\312\312\315\314au\242\277@\177\261\325H\022\274?\032\315\307*J\225\253\277\"\347W9\233P\237?T\224\354\331\214\014p\2778P\365pG?\216\277S\035\215\30123\275\277\206\246,\3351\325\247\277S\274\"t\346\300\212?\332\325\235\026\033\031\300?2\373\262\207\013T\252\277\020\001TY0\275\230\277\304\016\354\021\r?\234\277\303\220E\310\237[\261?\235\226\200\327\334<\301?{\020\257\034\314\205\243\277kD)\033\201\233\245?\276\006\014\231\356A\267\277\363\204p\3572g\250\277\023\215\241\027\300\347o\277@\321\0325\201\270q?\313\375Pz\350\332\261?\367\031\256\223\177\341\252\277\022\0046\000B\221\273?#\025\252ldA\223?\003\342\022\033R\202\273\277\036\360$\231*K\225\277\212\341\221\330\365\"`\277\317=\032e\267\361\273\277U\334gKcf\246?\273u\031\352\000\256\267?R\t\251\2276l\244?eS\212\302#\333\241?\375\343x\237 \245\247?\016\334F\344\274\245\304\277\223\314\t\346\217\215\240?\234\350\213pJ\367\252?\033\201\251\246\232\330\256?\3146\227&\257A\275\277w=*\242\363\216\246\277\374U&W\243\327\240?\2742\232\177\255E\245\277y\262\216\207\0053m?i\365F\3255#\266?\030\3257\345\231\322\231?W\324P\377\257p\266\277\242\347@\"\311\225\262\277R:H\2754*\251?\245\360\2579\245\312\270\277K\006m\350\346\r\243?\312\024\235g\323\340z?\233r\325[\315\345\260\277\261\265\345TT\250\230\277\2124\360\246akq\277\202=\024\\\307\032\247?0\t\"\312\242\361\231?\323\244\201\014\226\240\277\277\376oPn\013~\271?$N\022\263\304\016\211?ec\335\305\023C\252\277\236\"\233^Nm\250?\rd\314j\310\201\233?u3\342\324\242\341\221\277\211\272\036\347\345.\223?\\\010\253\342m=\207?\036Nu\032\214yf?\345(e\022L\307|\277\257\202`\346i\031\210?\365q\363X:M\203\277;\272,\326\206\352\233?g\004\375\001\227\r\241?\252\336\005\225\005{\244\277\365E\203\311\347x\234\277\226\231\345\201B)\225\277{\353\001*\274*\264\277[$\010\023=g\215\277Q\010{\336\305\374\225\277\372l\351\257\321\343\252?\234\025\332%\3345\264\277\"\276\0268G%p?\331\213C\275\325&\216?\322\333\230--\005\224\277c5\324\263z+\220\277\210l\246\224S\001\245?\312\373\276\\\314a\232?\255\345\005\231\375\353\245\277\"\2116}\355\240\223\2771\357I\242\257\203\221\277G\027\302\006O{\257\277\033\365\343\264\344\371\260?H\321S_\037\337\273\277\321\013 \212\267Q\233?:\255k\357#%\225\277\354\321\240\277\236\233\266\277\305\\\343F}\377\255\277\234@\333\277T<\262?\007\240\214\253\232\262\305?\334\274\300\246\355`\206?\366\3717.\300\313\260?\026p\224\366eF\263? \323u0\030_\265?$\035\025eS\376e?7\240 p\t\023\246?l\305b\220\376\235d\277\005;\303\177=8\205\277>\215U\212T\355\267\277\235\300\234\315\345v\231\277\303\'\251\27200\200\277ga\355\232\300o\177\277\303j\370k\001\362\221?\317\n\006;\221\201\256?\247\025\252\273\2452\217\277\250m\024S\004\203\240?\36597\372\"\363\241\277;\034\357C\241\273\213?\305\231\236\364C1\257\277\321\205\367ts&z?\003\007\"\234\236\217\252\277\234\222\211\344\223\317\202\277!\243>\246\272\277\266\277\263\247\203\200$\243\256?\310k1\267\365q\270?M\036\177O\"\301\222?Am\340t\343\302P?\376A\216\253\364\007\266\277^\377M&\022e\253\277\364\200l\025\271\226\242\277.\336\305E\036_\245?\312\2637\371\222\337\253\277d\273\245\322\301\202H?w\357\375o*K\260?I\353\213OR\367\300\277I\005\3734J\236\305\277-Y\252\363<\240\230?\351R\r\027`\266h?\272w1G\014o\202\277-\272\237q@\271\272\277\021Q\271\316\"\243\237?3,\377X2Z\252\277\244\034\236qlfx?\212H\022\002\266\352\262\277\021\347\265\242\324w\237\277x\240.\20158\271?\360\357\211.q\025\270\277\375\225Y\350^\224\240\277\005\310\337\214N|\271?\360\320\344\037i\000\241\277!\021\373VgF\230?@t\332X\3413\202\277\201\226\250\223\254\020\244\277\344\330\3653\300\345y?\014\225\357\310{\217\234?\014\236!\'\371\343\255?\224\211W\022\245\245\253?\nR#\022\342Z\242?f\223/\325\346\'\266\277h\267RaaP\274r?}\004\310`\373\254\251?\255(]|\233^\225\277\321T\316c\003N\237?th\303f&\027\247?(:\344\367L\033\304?\220\372\310}HOY?\371\207\363-\256\361\260\277j*\216\335\220m\243\277\020lr\276\013u\241\277\244\255\270\233OB\222?]OQ\332\0137\230?\215\272\231v\340\211\232?D=\302Q\245\210\303?\212\\S\365?\n\210?\214\203nFSc\244?\331\200\234\237\025\220\210\277V\245Xn\210a\265?\336\177\276\'\243\333\240?Ni\344\366\027~\225\277\033o,^\246\205\261?\233U:\010ll\260\277f\365\177\366\212&B?TO\306\004\022\347\202?\036}\374\306s@\251\277\231\277%\276\231R\244?$Xo\323\213\241\250?\350\342V\351\350\223\227?!Z{l\'\005\267\277\255b\003\201A\n\263?z\372\347\270<@d?\373[\327!\357\034[\277\325w\234\274:\007\244\277\326\177a\331x\202\250?E\022\017\313\330\345\227? \364U\350\037\357\201\277\355\211\211\317\241^\237?\2467\n\"\250|\246\277g\333\322\326hX\225?\204A\372\341\315\022\242?\006.\214\310g(\265\277+\260\307\312\005\307\222\277\000\235\037\362_\227\247\277C\031\3309O \251?~\3622\322l\003\243?\021\310\332Gu\201\260\277Z\177\377\243>Y\240\277\256d\247]N\274\265?\217I\276\026;\354\266\277\001\231\006\307\326\320\260\277\007\367\334\311\253D\220\277\303\003h\227\001\226\222\277\366\264\253\'\021\365\243?j\372KK\030x\302\277\004\267nN\342e\222\277\031U\305[&]\271?d\347\227\220\230/\201?O\032\370\310\333\321\252\277\276\013\002\023\364\261\257?\334\337\333n\370r\300\277\351\224*y\256V\276\277\262\252\026vi\242\250?\3346\303\365\013\251\226?A\206\241\336{,\230?\250\014\367\340\252\351\257?X\t\277\332m\002\267\277.W\024\267\242\316\246\277\356$\352#j\034\222?\260\304\321\367:4[\277\003P`\210\307o\257\277\343\334c\337\005\203\245?\342\241*]_\220\223\277;v\340\264\343\357\270?m\247WO\267S\307\277\327\277\215+\213\247\263\277\203k\341\373U{\275?\260GE\374\261\204\250\277\326\221\245\350N\330\233\277`\324\275`\355\370\234?4E\314\324\300\350\264?\361\254\006\204\226H\220\2775\352\232\217\230\272\250?$\255\'\"\027\320\244\277\336#\371\332Gj\236?*\314\364\215\361\"\220\277 \343\021V-\366\246?\312\353\034\253\362\357\246?;$\357\275\274o\303\277!\002q\235\365\301\245?l\2008F\007\020\265?\035\330\240?\350\264\261?\351db\337\335\306\232\277t\016<\306\262_\231?\033:+_\t\345\245?\177[\371\3267\263\222?\336Z\207\tj(\263?\370/\334\004S\tb?\000m\3236\003\212\206\277+\366\253\243{\255\245?J*\177\236\205\310y?\240\\B9O\246r\2775\004\016>\242i\242\277D\362 2\230\211\254?\227\302\0070\331]\272\2776)M\250\036\341\206?C\014[\377\345\254\272\277\224\353\357b\036\016\251\277\270\251\234\211.\004\246\277oV\3520-6\275?\300\307\273\2713\240\254?\332\376+\221\321\356\217\277\\\241\252\347FO\210?P\274\220\337\360#\302\277\240\232\236\340\271\n\221?\253\257\001\260\340W\246?\331\023_\256\203\004\226?l:\n\325\003\001\241\277*W\027\225;\235\221?X\006T\257\0328\217?\"p\233\361g@\234?\360T\316\005\2758\241?\2062\260\303u\337\262?\314r\257\2210\305\223\277_Y\0363S\316\242?~\215\033\277T}\214\277V&\214*?|\241?\315[\030\270\375\212\251\277\n\366m\362\n\256\222?\204\243\327\203\374\207\253?d\323\370\020g\264\273?\026\351\311\230\222\325\241\277\3242\244\207\277 \251\277\331~\367\255\231\014\301?\343*z\025^\253\240\277l\236\013\214\361\241\234?\204)\256\035a\366\230\277\274j\221OL;\236\2772\225>\331\324\206\247?9\364i}\021\r\260?$-^*Is\245?h\202\003N\'Vr\277+\003\247^Q\352\244?\033y\016>j\\\232\277\320X\217\256\"a\250\277\257\213(\377\3214\310?<:O\226\344E\252?\306\304-\337Q\020\260\277W\004y\373\330{\261\277=\267\301\375R\337\234?Q+\306\362\317\216\244\277\244\225r`\037y\254?R\270\tV\017\t\232?k\317\257\037Ki\252?\2150\316\3077;\261\277B\247\366*\246\000\271?-\202\371\001\203\342X\277\220\"F\315W\227\264\277\302\002 E\346Z\233\277\2069\355\027\243H\247?\316\274\003\212\353\357\213\277\235\203\264\314\334\017\251?O\343\210a\337\304\265?\305h\234\306s\313\271\277\003X\316\032\331\374\250?\033\343I\017,\225\260\277\270\037.\260cq\270\277\r\300\245fb\242\243?1.\271B[\212\232?^\2640\006A\241\271?\005\274u\312\236\320u?q\277L^\216\245\301?\323/4\366\3749\244?\241=\r\000\023k\251\277tC\333\033\001t\261?:|\321$\360\326\230?\251\036\306\016^l\222?4\251\245\341\033F\214?\237\264<\321\272\226\221\277\\\230\330\276\031\314u?Mv\356\304wr\210?t\2213{!\355\246?\006\207\213f\034\322\266\277\216\226y)\375\025\246?w8m`\233\234\260?\362\313\321\272\2453\211\277\203\213W\272\327T\252?\260\317\365fQf\271\277\305\000\234\241\335q\260\277\225:g\303\231\227\261?\330\213\255\016\177\016\216?\340&\262\323\013N\260?@\344\3153\264\367\263\277\001\303J\375!\226\250?\243H\2078\0009\224?\357\023t\314,y\235\277\316\354\331k\264\022\256?\300n\255\314\267\001\265?\336f0R\016\305\224?d;$\035\200\236\233?\241\242kg\374f\224?\r0N\016\261\317\266\277\001\254T\210\365\273\225\277\220Jn\027\276Ng\277\314\362F\220\315\035\263?\251\267\030\205\200-\215\277s\306\235\261\324\265\241?\007\261\214\220\355\364\264\277%\253\314\366\030\272\254\277\367\312\037\232!\251\264?\355y\nT\255\203\264?$\302\020\347\007\206\251?(\225\237\371\321;\275?\375\005\365\01030}?\235\227\005\273\321\253\213?i\370\261\372\035k\272\277\364\237}[\311\203\266?uR\014u\271\221\267?\231\242d;\345l\274?\216\223\206\341\336\273\232\277H\234\361\227(\027\270\277)\303\020\2375\211\264?\360^\201c\006K\245?\343y\006-F)\226\277\022\202\254\337\335|z\2771<\257xL\n\224\277\013G\210Yd\302\262\277\323u\345J\373\303\270\277\242\315\343>+\215\270?\354\342\215X\304o\247?b\345>\332,\303\275\277\345o\240\266\371\326\236\277\320\307\221T\316\266\242?\323\266\356\366,\312\275?\352\'\032\360l\371\255?\313b\302\375\331o\037\277p\256\251o\t\014\253\277{.x\317G\302`?Je\277\230\"\345\240?\236\323\304\345\343J\255?\313\317J\366H\371j?=\020\234?LB\236\277i\343\027\272\001J\256\277w\360\243\020\204\260\305?\3423\272\006Q\307\222\277\344\n~\357=q\260\277{\256\307@\020\361\261?1\'J\337z\017\302?B\353\0007\025X\256\277d\347~M\225R\233?\203\324&\375\350[\244?\263\024\307T.\252\276\277\n\3176\303\000\260b?)\371\256J\216}\263?\002\343\036\\\263\303\227\277z\354wN\276O\306\277\213\266\244y\2753\263?\360R\260\235\231\t\306?\321@_n\244\313q\277((\"\024\327P\202?l\243\247\353\371\231\202?\3256\211\n\r\337\260\277wQB\365\014(Y?/\340\254\\\"\326\263?\330\247+\342Xeq\277\262T\024\210\351a\237?yZ\007\214\031\220w?=\232\233fG\240\241?R\273+\010\001\365\251\277\367.\277\004wr\223\277\332\231\026\243\231\352\242?d\037e\326I\377\246?\326\313\204\356;7\252?\331\337\200\355w\025\217\277o\n\344wZ\273\256?\230C\001\377\036\306\264?\r\302\244\"qy\256\277O\377\247\315\261\304\264\277r#V\345\254\227\275?N\357\205\213\366\242\267\277\013\335g\320\261\245\177\277\316\333u\313Np\260\277\320T\004\2357\361\222\277\325\235S#\353\007\260?\306\372t\246\252\262\223\277\220\250^\\Di\216?\354\247\267\177\300A\254?,\244\275\320\2351\232?\037\326\345\314\321\305\273\277\030\236g>2\363\300\277x\335J=F\361\257?\021)\232\244\211v\250\277O\210\351\233P\277\276?p\253\031\345\251\202\213?\210o\202\331\343\214\266\277*\207\334t\304\336b?\367\\\300`Bm\255?\306\373\251\355_\376\274?\230\217\343~\257\245\254\277U!\3074\3141`\277\337\222\'~\261\253a\277\007e\000\363\034\222\252?\354\005\202\0030\351\261\277\265\313P\357\370\024\240\277\353\265\303\023\344\001\241?\234\213W-\234\337\244\277\004\356\036\216\331\227\226\277\021\r\201\222\026\371\202?\230\340\315\224Y\374\244\277\206\300&j\275q\200\277\326\330a\227\222$\272?\'+p>2m\252?\244g\250\324a`\260\277\017\260\267p,L\236?\256ECu\222\376\255\277k\252\325\2148\332\236\277J\210\231\233SV\251?\r\364\227\245F\340\266?\311\313\016\207\030\206\232\277\340\210\212\326g\035\234\277\006J=\367\374;\247?\\\272\347\022nr\255\277\373\014Y\257\363\347\271\277\273j\263\233-\224\260\277,-E\020z\264\242?f\211\275\212(\'\266\277\242T\024\256\221\237\240\2772\274+\325\3531\317?\022*J\237\243\007\260\277)ie#EX\246\277\020r\262\213\235\002\227?Wm\240\333\334D\235\277{\366\325/\310`k\277\302\222\342\\\262\371\265\277]#\277\023\242\214~\277\351\227\211p\205\363\274?\022y\264\031\370E\246?\335\025\230\2636s\255\277\302>s\374\002\005#\\\256\254\277\237\017\312*\316\357\237\277\002I\263\236\0021\301?\341\374\273\354b\324\264\277OD\004\205\340*\237\277\013\370\300\341\023G\262?\177z<\375_\321\203\277\036\302yQ\024\276\273?\022\022\236G\370v\230?E\337]k\345\327\264\277\0004\366\033\010\313\235\277S\021\222\357\346\213\243\277{\364\314\005\215.\246\277\322\306\215\'\366l\253\27701;\251\177q\201?\004i>\023\004\221p?\305\207t\220j%\224?P:\037\256\221\'\227\277e\203?\016y\244\200?\351\212\236\236~Hz?\266\342(\321\370]\270\277@\234N\375\\\340q\277d\331\240n\343w\242?\214DRZ\311\013\245\277\305\r\220\3424]\267\277\225\034\231u\'\224\231?\371\210\273\266N\255\257?]\016\317\377[\356\252?@\277\r\235\211\334\247\277U\007b\201)?\252\277jsa\222\372\214\265\277{!\235\3345G\216? \214\303\217Li\221\277\262#N;\251u\230\277$\032\205\253\027z\220?\353\267\3648\177\205\201?o\207\337\334\313\244\231?X\003\201\035\306\305z?\207\355y\0062\275\260\277^d96f\004\232?P\3012\356\205\017g\277\341e\0007E\262\246\277yI)o\300\377\274\277\"x\376)p\000\240?\345\027\375L1p\265\277\203\027/\274\rI\266\277R\201\033\032[\222\263\277\014\277\277\035\273j\260\277\004\031c\000\360t\257?\253\321\010\357\303p\262? /\217\031\022\246\262\277\341\250\222z\240P\263?\217\210\r\005\222\355\305?+\276\231W\337\277\272\277v\031\321\260\3135\251?\"\242\306@ \260\232?.\332#\304_\274\236\277\357]g\305\3438`?R\0212\n7\031\222?2}\225\364?\010\207\277\2712T[\017b\276\27755B\363pj\265\277\201\253\235\221[\035\257?p\351\020\260\030f\302\277\367\355\214\257:\013\255\277m\312\304\306\252(\244\277\250\257~\025\345\325\242\277oK!\022\360\206\264?\326b\331\370\342u\202?\305|\305\210\263\230\216\277Pu\300\n(\014\220?N>\316.\323\331\262\277FS2f\004&\271?\311~\237\300\241\306\271\277S\305\233\262C\357q?\247\027\217\224\354Y\306?\206\265\325\034\t\251\263\277\352\032\017O?\232w?\355\363\237P{@\202?u\261x\261$\224s?\317AF ($\241\277\350\236\274\212\275A\261?\3240\037\016\302\256\252?gN\354\310Ve\252\277^L\007\303\245\231\257\277\366\001\313\312\262\332\247\277n\202\rl\007\267\251?\335\257Y\347;?\247\277\345#\221\267\250~\263\277\316^M\265tP\213\277\205\352\202\321\3723\254?\000\273J\255;\344\267\277\014\361\263:\024\255\237\277\335N\025ZF\324\230?GUC2,o\267?f\022\236\252\"\250\267?w\203\037i6\363S\277\235\225p\375\n\342\264?w\005\317\013h\325\262?\205\321\234E\033-\210?\332\034h\333W\300\204\277\354\031\377O\216q\305?T\"\3661)9\224\277\r\216d7\247\226\302\277IH\352\307|\225e?\032\211}\262\346\331\265?=-Glw[\261\277\201\340\371g\023\375\261?\267\337\257\303\000\020\230\277\302P\241\251\353\037\307?\364C\322\224\232\263\263?\225%\177\331W\222\270?g\226\352[\354\275\263?\001\357h\311\005\330\300\277\004\317P\375,_\242?\321\177h\202V\227\270?:\371\254\370\251\207\257\277\001\355\3466\300l\245\277\274\033s\321=\263\243\277\t\307\274\332\026\355\255\277d\010\370\002\372\220\224\277\261\204K\'\252/\260?~\256\251\000\263F\254\277K\372vz$\345\256\277@\030\364\226a\300\260?_\377\025D\0072\256?\371\226\300@\232\373_?S\207\214\353u\036\226\277\325\271p\313\337u\270?\356_\344D|\330\243\277hxRv\365?\203?\310\007\201d\320$\207\277p=\'R\033[\230?\257\2326j\304\256\217?\276\235\037\245\323\212\241\277\356z\205\301\364\375\261?q<\207\226l\201\245\277\225\363\026Z\305W\224\277\017\213\343\316\367#\300\277\220\221\000\201\342C\270\277\300*\254\357BJ\300?\004\014@\202\2015\224\2774\323P\270S\263\244\277\301\300\322\233@\346d\277b\354J\251\232\363\231?\273\265\347\r\244r\260\277\006\263i\307\253\240\275?d\036\345Fi\304\262?\204\311J\253\335\"|\277:\003\313\177F\304m?\'\214\033\032m\321\243?\224W\201wRV\272\277\037N\241\226$\241\240\277\206\364$\250\232\341\271?\341Ka\330o\266\253?\207K\330\024{?\301\277\324~o\337S\037y\277\266\321\221z\r\342\244\277`\341\271|K\265\244\277\242x\232\251\267C\260?\\|\202\324\002\301\264\277\rPhL\367i\272?\267\277\245y4\275\370\017n\277Py\360\255\373\302\240?\355\202\307:U\277\217?\375l^\002\254\372\223?\223/*\024_\373\240\277\264\323\225\342H\300\266\277\005\272c\377\1779P=\234?\243vG\352\3257\250\277\351\350\204r\231\t\243\277\205\376\360O %\264?\237\315~\246.\270\306\277\236\300\324\013\213\224\216\277\220 \360\316*\366\226\277\311\362\3443\177\214\241?,j\214`\201l\242\277\205!\317\257v\214\264?\305\260j\272\3139\223?\273\005\364\3642\002\247\2776\345\034dV{\247\277s\327\3206(\217\266?\354I\353\233\3408\246\277((\027-X\242\233\277\311\334@,\334y\241\277\205M\330JGh\225?|9\275*\'[\261\277\357\366\367\203\273\225\262?\272\222YJ\263\337\245?E\r\251\356\003\031\273\277\237\373\263\346\025C\234\277\306R\232\002\327\252\264\277`S\374n\331\260\244?\324H\272{\251\266\262\277VC\305^/\331\305\277\365\351\016+\023\200\247\277\265\301{eA\350\222\277\304@\274.K\'\252?\276\035\247\332\340B\237\277n}\224\205\367\225\252?\3551\354\010\022\264z\277\251\330\325\'\260\242\277\277\212\257\233\016\221\262\246\277Dr\031\0130rv\277\264\361\325\271\004\357\220\277\204&HdF\370\244?[@\231?\274=%3t\310\240?,\325\371\220o>\300?\030\3360G=\353\337?\321\345\247\201\001\254\330\277\346\332b^!\037\335?0\217\342)\234\355\251?h\310\301\327\230\'\312\277]\017O\371\326a\225?\275\216\312\350\014j\244?\0032T\025h\237\333\277" + } + } + } +} +node { + name: "layer_1_type_0/matrix/read" + op: "Identity" + input: "layer_1_type_0/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_1_type_0/matrix" + } + } + } +} +node { + name: "layer_1_type_0/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "\216\230d\001Eg\335\277\237\342uCcx\000\300t\037\200v\031d\346\277R\200\006\262l\007\330\277\250\274.\264\264m\361\277:\256\355\272`>\000\300\306mk\313\216I\350\277\003\371\374O\203\021\364?F0\260{\205{\324\277\310\"$\257\214JJ?" + } + } + } +} +node { + name: "layer_1_type_0/bias/read" + op: "Identity" + input: "layer_1_type_0/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_1_type_0/bias" + } + } + } +} +node { + name: "layer_1_type_0/MatMul" + op: "MatMul" + input: "layer_0_type_0/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "layer_1_type_0/add" + op: "AddV2" + input: "layer_1_type_0/MatMul" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_1_type_0/idt" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "\025\017\275[ &\265?\177;\274/\226\223\270?r\362\235Y\023v\303?)}:\237\334\000\274?c\244\366\201\204\020\302?`\342\312t\223/\256?J\337\373C\310D\252?\013\215T\020\247U\251?\203\026p\3439]\240?Q\276\375,\314\301\267?" + } + } + } +} +node { + name: "layer_1_type_0/idt/read" + op: "Identity" + input: "layer_1_type_0/idt" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_1_type_0/idt" + } + } + } +} +node { + name: "layer_1_type_0/Tanh" + op: "Tanh" + input: "layer_1_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_1_type_0/Reshape/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "layer_1_type_0/Reshape" + op: "Reshape" + input: "layer_1_type_0/Tanh" + input: "layer_1_type_0/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_1_type_0/mul" + op: "Mul" + input: "layer_1_type_0/Reshape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "add_4" + op: "AddV2" + input: "layer_0_type_0/Reshape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_2_type_0/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 10 + } + } + tensor_content: "\036m\313\032\006\261\241?\016ZZ:\375s\273?\357\007^X\350N\322\277Rg\361\333\344\351\302?\321\203>X\326\240\260?u\334\315\325%C\336\277\036H\016\324\257<\307?\257\031\270F\226\362\202\277v\351\242N\334\333\300?\263D\372\232\375\035\327?2\027\341\315\235\271\332?H\200\016mE\374\300?\312\361V\257k\264\326?7\230\343z\014@\336?\004\316\016_\214\017\300\277\377\031\220\305k\032\202\277iN4\234b\327\306\277\246\224\316\3727\313\272\277\235\277{\354AX\333?\364L\003\333\254\203\326\277|\303\267l\354\032\267?w\\\254\3240\266\272\277\363;\227NGa\306\277U\232_\003\222\230\300?K@]\\J\225\311?m\264\365V\353\332\316?/=\207\351\033l\335\277\377\324\3075\005\347\246?X\231lH\243\004\327?\264\220\346\305\014\003\327?`\363|R%\237\255\277\215\026AvB\\\332?e\021@2\302\020\271\277\017_@\367;\377\325\277\232\364`\004@\316\263\277\302\256\024=\245G\223?y\027\256C}\202\242\277V\231\253\305\345Z\341\277\223@:\314?\221\227\277\253\366\276I\263\r\320\277c\300O1\"\273\235?\307!\037\343\016\375\311\277 \373\006\303\214\002\301?\253\327L\244\355a\277\277u\206{=\320\246\317?\202\347\272\337\240\217\271\277v+\016\023\023\213\266\277\356\210\217\276\034\373\320\277\256\027\207\177*\303\322\277\262\346\030u\332\340\305\277\310\231\212\217\306]\270?\025\264\256\244B\261\247?\236lEL&\242\331\2770Q\221\023^P\320\277\304,\216`\352_\270?\035:je\225P\271?\352\006\277T:\355\217?u\034\230\317\223\275\225\277;\\\331\253\347<\310?fM\273g\021\316\231\277\271m\225\201\034\341\262?\017\231\260\3541\306\240\277\327\007\342\032\027q\257\277\334o?V\031\215\334\277y\351\000\316-\t\305?\243\023m\237\026\'\322?7\347%}Pb\257?1\273\335\247\031\200\304\277\246\364\037\311\363\022\304?\036\246\351w2\377\305?B\251\272\355* \321?\026*\214\276\343\345\304?\033;\262\210\3752\261?\327\3527xG\323\316?\340\344\265\304\346\274\312?\004\377H\377\323\241\340\277Y\315qk\210\322\307\277x]\0008\301A\240\277I6\362k7\r\327?]\354\305\303\016\335\206?\221\363,\034\321\366\270\2779\006\307+\365\026\303?hF\014\343\265\255\336\277q\\\210C\262\032\323?{&\333\366\013V\262?\006\207\252\226c\n\262\277\033,\236MFd\273\277\232\215\243\367f\300\302\277\372:u>\312\017\245??\004\324\355{\200\307\277g{\004:\216\213\321?\024\346x\022\2735\304\277\023Q\224\325\315\007\240\277\013H\232\350\204\212\327\277\341\376\254a\337$\327\277Q\004H\255\200\210\276?\336NwV4\310\246\2770\026\021:\005\346\340\277*\226\226\025\255\333\255?\225\024\3717&\270\260\277" + } + } + } +} +node { + name: "layer_2_type_0/matrix/read" + op: "Identity" + input: "layer_2_type_0/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_2_type_0/matrix" + } + } + } +} +node { + name: "layer_2_type_0/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "V@\235\014\330\243\366\277\\ \351\026e\037\354\277W:\274\307S\270\322?\271\303j\013\036\204\317\277y\t\221\301\036\177\363\277\311\010\304\210XW\335?E(\\\247\227\210\326?\315\317\274\026po\356?Y\304\002\332\005\216\375?\234\265\371\320N!\353\277" + } + } + } +} +node { + name: "layer_2_type_0/bias/read" + op: "Identity" + input: "layer_2_type_0/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_2_type_0/bias" + } + } + } +} +node { + name: "layer_2_type_0/MatMul" + op: "MatMul" + input: "add_4" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "layer_2_type_0/add" + op: "AddV2" + input: "layer_2_type_0/MatMul" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_2_type_0/idt" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + } + tensor_content: "E\001\335\035\241\343\267?]{3D<\013\270?\267\201o\352\004\253\302?\242\326\235jN\010\272?^\253X\222\334\375\301?\326+i\274K\017\274?<\316\031\375\373I\222?O\221V\310Py\247?\306\211&\362\317\223\270?p\212g\262\367l\273?" + } + } + } +} +node { + name: "layer_2_type_0/idt/read" + op: "Identity" + input: "layer_2_type_0/idt" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@layer_2_type_0/idt" + } + } + } +} +node { + name: "layer_2_type_0/Tanh" + op: "Tanh" + input: "layer_2_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "layer_2_type_0/Reshape/shape" + op: "Const" + 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\n\000\000\000" + } + } + } +} +node { + name: "layer_2_type_0/Reshape" + op: "Reshape" + input: "layer_2_type_0/Tanh" + input: "layer_2_type_0/Reshape/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "layer_2_type_0/mul" + op: "Mul" + input: "layer_2_type_0/Reshape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "add_5" + op: "AddV2" + input: "add_4" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "final_layer_type_0/matrix" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 10 + } + dim { + size: 400 + } + } + tensor_content: "G=\277\211\274\247\270?\356\034Mb\253\330p?\301\221{*3I\252\2776\346o8\020\231\275?\245T\330\374\321\361\311\277\264\313\224\310\262l\257?\313\3000\r\033\325\277?9dT\352\344 \274\277\355\247\310\241\357*\272\277\027(\232\200m\020\264\277\036\206\313\031\377\364\302\277\256\022N\020\376\266\263?\265)\334\271\013+\261\277\336(\\l\275\360\333\277\352\363\037\215nO\277\277\225\244\2569D\311\322\277e\211\014Ju\370\303?C\333\323A\007\357\263\277\256\303\260\202\306\303N\277\254\030\377\002\3339\262\277u\021C\271\213\242\257?k\372\227o\311\251\302?\2723\273o\306\231\263?\'l\356\327\035\030\272?\204q\026g\003G\271\277\225\237\376X\000\251\261?\341\030\374\246\177\026\266?Q9b{z0~?Z\364\306v3)\255?\225\'\004\003>\226\303\277\005\373\224\367\273i\250?\337g~\034\177q\240\277\246Z\256\246\007\254\254?\361=\004\364\346\004\241?\027N\221\374\237\255\257\277\250\014w\370\376\373\233?\264\340\232\030\357\320\245?f$\303\265\356m\247\277\311\317U\344\033\257\232?\225\2560\205\345\207\231\277$\216\0065\202\252\303\277\337\216hI\263\266\270\277O\320\330\271\316\222l\277\211cS\366\223p\304\277\215\350\327;\002T|\277\003F\271\352\354\364\275\277\314\3253?\021\265\237?`\367\'?>{\266\277\001\220\321f\310\023\262?S\020\267\345_g\262\277\272f\213\214\277\335\202\277\327X!\365 \356W?\225\035\004s\217\330\262?.\277\262\377\036\324\247?\206%p\310\201vs?\\/5A\372\340n\277\316\231\006I\032Z\204?\035\024\333\375@\333\261?\246\353\260TQ\373\215\277\327\244\333\365\277j\253?)dW5\376+\244?\351\246\353\277\326a\254?\230\312\221>\002\265\270\277Y\335\3700\222T\246?\237i\013\274\010\336\276\277T\341\362c\212}\213?sFtPW\013j\2779A1\312\240\365\306\277\375\035\375\210S\371\240\277\201\223I7\343\321\275\277\302n\360\002\215\357\274\277\344o\027dH\336\265?\0065\233F\330\202\306\277\255^,\304HB\256?\343\032U\026\314\210\250\277\037\235+U?\352\242\277\232\322\307\241\036\374\200\277[\217\232_\007\266|\277\036\352<\324\227\275\306\277\277\210:\037\275\331\307\277\223\0378\224\027#\314\277ISB\255\377\232\245\277\235\367\315\205up\223?Wx\301\315\332B\265\277Y\241\314\201\236\337\271?AI\345\254B\361\302\277|\376\260\360\213\220\250\277xtA\253\005L\252\277\220E\241W\313\033\246\277\370;\032\265\204N\241\277\330\266{\272\007\260\263?\326RS\205\002\375\247\277q*\025\326\020`\243?\267/\t\022\016;\276?X\215hi[\274\234?z\312Vr\374\000}\277x\177\323\0174~\253\277\225\366 b#\310\252?q\026\373\355\254\323\257?\231\211\265N8\323\203\277\030Q\204\351d\205\233?\263\2736\241\324\263r?\0303\341\311\010H\234\277\035\266\265\005\240\024\261?\260\031%S;e\276\277d\004-\260\025K\251\277\310\307\235\273\217a\245?\032S\214\301\225\246\320\277\360%\370\236T\373\250\277=\360U\032\262\301\262?5\346\225\352~\177\275\277?l\3201\370&\314?`\307\202 @\017\305\277?Qb\351nl\271\277e\242l~\347\314\226?\013\r\"\330g\341\277\277\216\242arX\312\262\277\374\215\251\274\006r\262\277\370ALx\352\242\313\277\341\307\35246(\207\277\240\313w\325\351\316\262?\344KJ\351\027C\247?_\321\302\315\277\\\241?\236\354R\014%t\224?:\211\256\373\312\323\217\277\004\304\274\322E\322\244?,i\023\365\251\341\251?\220\255\332CTy\244\277q`1L\305\014\203?\242\016%\317z\372\247\277\367\362\260_\027\221\272?5\270\001@\021\273\216?>\340y##\335}?\264\224E\004R#\252\277\230\367\360\n\214\014\262\277\374\315V\022!\303\027\277\336Z\240S\321q\244?\202*\320\222]6\236\2770\305\003p\226\247c\277\303p9\327\205\212\300\277\335\237\035\226\221d\274\277o:\225\r\003\306{?\273\234Z2<\266\236\277|\324\332=8\221q\277\005\272Cm\353\250n\277\332\306\005W\006\352@\277G.U\006;\355\276\277N\0205!%S\262?\263\315\260\007\032\201^?\375\232\211\351S\342\265\277}\ty\3558\034\226\277\355\361\377\206\333z\302\277>\203\001\227\254\251d?]|1\363\373\3075\277\277@@Q\035\224P\277\373\217\017\272\246\n\211?\370\215\2270\035\253\212?\024\017\233\320\264h\227\277ZM\350\323k#\211\277\016\365\231F\n\332\262?;7\254l\364\211\263?\030\'d\'\240\321\210\277\255\020>\273\016n\246\277\024\030N\205\377\276\260?\343N`\212\360\010\302?\317%\255c\3643\214?g\225D\036\362[\223?!\345\340\204\306\337\300\277\324\346Z\262\0277\234?\\\020@$\270+\270\277\347;>0&b\261\277R\315f\225 \367\252\277\206\303\rT\242\370\224\277c\377\231\354\333\322\242?>a\305\365M\263\242\277\031\276\016\252\243j#?\177\022\310\014F\221\215\277\252\rBO\335Y\270\277\025\031\013\030Zd\204\277\311oG\362\006U\222\277z\310\211\013Gf\227\277f\202{m\350\352\221?Kxr\036\177\274\265\277<\210\034\215jc\200?\030\373\372\006{;\246?\212\331\317R\001o\230?\357\216c0D\225\313\277\367\357d\017k\350\300?\230B\331\323\000z\225\277U\300t_\321\210\247\277]\373?1\032\336|\277\2317\232\314\334K\271\277\024!\321to\333\237?dG:{9\261\273?\374\334D\177\315\217\260?V\030E\201k\004\226?U\350n\022\312\242j?\253:\227\364\360\034\263\277\233Sk\201\372\273\242?I\272\375\345r\330\207?\010\324W\207\031 \242?\221\264\234&_%\233?j\272\307m\030\036\264?R\240f\\\303\330\250?\002\370\247i\260U\267?\264\265\023\032\335\362{\277\271\371\004}\230M\224\277\245\370\275\372\337Vm\277\263X\252\t\\\253K?poI\336\260|\253?\367\225>\277\214\347\262\277\221#\357\261k\230\314?w\231\311mA<\224?\225h\254\324\333S\251\277 \202/hI\033\230?\272\336X\257\300\343\266\277m\227Fz\331\215\231\277\366\344\'A]\307\257?\266\234\325A\236\301\244\27725 \021\332\275\224?M\341\0326\036\340\272\277\024\267)-\200\224\220?)\022\261\323\335\211\204\277C=\350\'&tc?(\032\330aw\343\221\277\306\262i544\230?8N\367V\261\332\263\277\246\267n\320\025\257\215\277\332\227\254\237\340@\220\277\376q$\"\313q\301\277\300f\340TV\330\263?\261\266\335B\000\200\303\277\255_\020\332%\356\257?F\222o\013\224\316W?\221\330\'\253\217K\221\277\331\211\354f\335\333\213\277*>\251y\275\236\261\277c\267h\373\222\231\237?\301\254\211\363}*\241?A\314\322\265\0232\233?\036L\324\271j\244\242?\214\231\n\361E\004\217\277\017\352\257\307\014\212\241?_\362\036\306\202\335\240\277w\352\311\272\337\270h?\010!\334\303\340\217\227?F\235\204\271\234{\332\277I\346`\272\205M\245?\273\361\343\355]\205\257?\216o\314n\327\010\240\2776\234\334\245[\231+\277w\255\302\253\256^u\277\267\254\004 \017t\267\277^\343\301\036\023Kn\277\276\267\302p\344\254\237?f\250d\233\267\001\205?\004\3066F\272(\252\277pX\022\007\016\342\253\277\001\262\001\204k\210\261?\202\222\222O\007\355\245\277\030\252X\331\003\325g\277\217#\210\'@6\240?\342\301\361{\233s\266\277\235\331\317\373\370_\251?\013\243\'\261\013\002q?T\324\255\327\372%\240\277va\026#\202;\276\277S\352\257E\031\257\240\277=O0S\253\317\261?\342\032%v\364[n\277\277\031\235\035h\257\213?\263\213\332\210ir\204\277\267\323^Q\037$\227\277\020N~\270\354p\272?\263\302\375\267\246\207\301?az/WS\002\226\277\350\035/\230\354U?\362\313Q\270\270G\232?;C\360\365w\345\215\277\233\366\352\206\267\321\242?\274=Fr!s\260?A\210\226Q\326\333\213\277\235\026S\370\330\276\254\277iJ%|\016\033\263\277}\230\364\266U\244\241\277\ne^x\032\006\227\277x\341\272\200G\023\263\277py@\323d1\275\277\241\253\374\351{\277\273\277\363\244\345\256\212\202\266\277:\353\227\266\225\256\320?\217\220T\2358\306\245\277\252Y}e\227q\272\277\223)%\251\242\325\222\277\rG\355:\203\334\230\277\204\0006\2317\336\243\277\261\350\314\354~\262\261?W\353\364\367Fx\257\277\024\216f\253\220Z\274\277\313\375N\036\374\330\245\277q\001$ X\227\232?\036\317;\177\215O\202?\'\026i\036\200ez?\247j6nO.\263\277\337\351\303\352\221\217\255?l\235b\026\201\375{?]q@l\003\r\216\277W\306l\317+\363\263?\304\224\034\3758\277\276\277V\003f\354r\221\220?\030g\202\314\221\221\264?ii\305w2!\270\277\272K\'\232\\\363f\277\220#\364~\r\370\235\277!m\321\030\330\354\236?\357U\3536\233\220x\277gU\217\202W+\266?cZ\335+\262]\312\277\213{\207\202\217\322\201?\030\'n\306\340\317\256\2775n~{\317\256w\277\231\3439]\334\255\260?\372\007Q\222\230>\246?\330\351\311P\037Bh\277\342h\200\222\241\023p\277\200\266x5W\353\253\277\247/ if\257o\277\272\t6;&\014\245\277\226\244:\004\2410\235\277\264\223\206\311\r\035\250\277\314\227Lq\236\241\205\277CR\356\375\223\277\246\277\001\343xZ\204\373\264\277\305\317\337\004\303X\224\277\341\316\330\257\330S\260\277\211\351\342\245\367w\206\2779\276\276/\245^\310\277\036H\245YU}\206?\002\325\221\342,\327\275\277\324\360[\341\271\344\246?\320N\206\346\223r\202\277\211V\322\241\211l\253?WL\261\025\365\306\270\277\253L\024e\222\007\307\277\356\37361Y\230\216\277AS\353\010\354\310\212\277\237\307\236\355\356\006\225\277\254\364\322]\200\212\273\277\255\336\033-g|\214\277\361\010\315XD\034\272\277\213fqWTy\260?\206l\256\2751\341\265\277\270\r\336v\253h\252\277\025&\306\222[N\303\277\330\373\231U\215H\233\277\216\t\263\302\324\211\270\277]2\233\373\274H\270?\264E\016\317\337\303\270\277\362\220\314\236\005E\256?\377\377\250\305p\263\247\277\313\033b\204\247f\254?\342S\024?\210\347\201?\221\304fS\322u\215?e\221\036\203\330\354\262\277\341\024\025k\276\325\226?\371\232\336\375a\034z\277\301\251\365-\2465\260?\'\330q\221\274\301e\277B\350E\242U\206\215?jL$~\037n\242\277\000\315\021hH\033\241\277]^x\341\217\302\237? \227\014\253A.\207?N\364\211A\323\002\243\277\037o\370\277\004m\202\277U\270\005\305\352\206\250?#\324\027\231\0000\272\277GT\202\266\003\022\224?\370\321\263\2650o\262\277\216l\371\2635\ng?m\3003\251\212]v?\276T\021\244)J\257\277\006k\277\316\231\003\226\2779;\262\366\312:\216\277\002\340h\311&\036\242?\336\032}c)\003\310?\377J\004\010\372 \303\277\2109\204w$\333\265\277_\340\007V\232\246\201\277\t\271\225@\375N\275\277bJ)\351\022Pk?%}\334U*X\225\277\233)U~Q\332\263\277U\376\265f\312\201\201?\363\360%v7\232\223?wq\017\333H=\260?\013T/\356\342\214\222\277\307V\373q8a\242?\332K\'+\360\255W\277\376\212|\027\330\000\232?\215{(#\rV\205?\373x\225,\356\232\223?T2\346\241\013X\262\277Y\357\265\350\351r\251?\324\310\246z\374\277\274\2773X\255?v\213\227?\026i\344\323\027 \231\277\211O\023@\324\372\300\277>!\251A\363\250\240\277\234\204\307$\351\360\261?\n\267\332f\326|\273\277@\0056Z-rI\277\334N\032\353\033Z\276\277\343\377\013b1E\243\277\033_1\302\016\367\260?oY\263\342\341;\240?7\233\335\254\231\031\262?\t\261\342\246~\031\216?\321\250?\017B\3177\276\005\222\277z`\002\204v\014\250\277l\370\277Lg\242\251?\267\237\367v\373k\212?\014\325\206\233\006P\250?\216\223\311\2619,\222?\355hO\231&\221\177\277.\205C\357\234A~?\232\206\376fK\002\260\277\274\223\220K\234H\200\277\210\023\2002B\001\261?\235:y\310\273\373\216?\315\300LH\373c\257\277}mxU\311\226\205\277k\321\232Z\013\323\270?g\271\232r\317\340\273\277\365\333\000R\267\202\261\277_\360t\271\322\262\216\277\007\337\371u\306\334\263\277\036^t\226\020\215\205\277l$#h\r\222\224?.\363+\3126\216\205\277\270\331\335\336\200\377\206?j\247\023\177J\336\241?]q\305\313\270\r\231\277\267J\276\2159n}?\023\201\030\314\253\351\265\277YK\375\024\203\025\257\277\302y\276\366\327F\223\277\214{!\267\345\273\240\277l\247W\246\317\306\226?y D\224\277D.\264\345F\202\241\2771\177M\222.|w?\317[\2274\215\377\232\277\337\222ig\177\310\260?\003w\245\316{\335\270\277\003\025\361\321<(c?ER\312\256\330i\241?\352\341\371\341\325\031\243\277\357(aD\331P\233\277\322\177#\371\263#\264\277=\373\213\345_H\270\27789\334*\246\r\226\277\277\2709\271\202\337.\277x\320\257\023\177\216\200\277\254~\312\027\tl\222\277\206\323h\023\177\306\307\232\277\252\tn\247\200\004\261?\226%\033W+\021\272?\352&\3040\203\354\271\277\370\350@\rc=\241?\313\271J\222\023\222\242\27750-\312\274P\241?\324+\241R?\257J\277y*G\025\230y\227\277\243^\323\235__\224\277U\236$\313\245?\232?\276\254n\'[i\271\277\305r\271\326\200\261W?T\315t\007TH\235\277HM\331\351\375&\247\277\024\306\232\017\326L\215?\"s\355]J\226\275\277~d\246\027\256\312\202?Vj\350\315\227V\262\277\007^\252W\204\206d\277\317\000<\251c\273\240\277\224\324\004\323B,\242?\3129\245\325\340\016\301\277\235K\201A\255\350\216\277\355\302\200%\245\277\257?\276w.\302\270\261\233?*\330=g\270\350\255?\246\343\354n\001\376\240?\361\250\246\322\342`\235\277dU\331&\325\242\217\277\332o\2321\231v\177?ns\002\302\243\340\263\277\214v\262\262\261\310\264?D\361\276\250\342\351\214?\350e\227\370m\300\264?o9u\310y\207g\277k\351\351\255D(\263?\312\221\264\321\361\366\303\277\262[<=\'\211\255?\232\272\2719\023\034\270?\357Ik7\317\271\213?\304 \315\027\203\037\215\277\200\236\327\354G\335\223\277\346\020\201\273\003^\242\277A\322*\304\'\315\274\277\203D%\211\337\337t?\362\277?-\237.\267\277\270\03265\215J\243?\336\"\371\335\307\032\201?7x\246\241$\233\220?\010mg\260\037\237\267\277\026\246\315B\rP\261\277TwPSc\244\242?\006&D\341\270\320\224?\3608e\263\356C\260\277\256b\371\302\336\213\247?\203\366\2218\255\357\243\277\376\206\000^\275\037\301\277\000!6\224\242\234\213?\214\024\327%\006\343\207?R\266\275\324k \303\277\'3@\024\325%\241\277\354\010N\201\0062\270\277\362\013\271;\016F\260\277UV\302\010\237}\262\277hjb\340\203\261\256\277\014\310\003\242*\242\227\277n\265d\365\335\322[?\274\205\351vv\007\276\277\001\024#\260F\013d\277\377\221\361\331\257S\253\277y\345\343 \306\323\230?\023\273X\363\351\t\252\277gR\225U\355\222\200?\322L6R\326>z\277\324\r\376YY\326\256\277#\3727t\234\200\247\277!\332l`t\344\273\277\327\313\367\224\344\315J\277\346\336\271\226+\212\241?\032F\266rz\233\257\277\311U\022\244\037\240r?I-\347\212;\203\222?\301q\267\225\345\255\231?8\361\273\003yZ\244?\231\242*\320Rj\214?\345y\360r\355\220\240\277Y\335&\210N<\237\277\266\265\264(\023\360\246?\037\353M\221\241F\222?\261\252K\347K\013\261\2775u0\360\376\221\300?|F\206\231\276`\205\277q\267@\317iP\222\277o\2367\327E\034\267\277\272\244\243\3652R\240\277B\365\213\230\376<\240?J.\3739\331X\261?\374ui1\021\364\261?\033d\375h*~\242\277@\354\330R,\022\302?Mb\326\277Z\201R\277\315\373\006~\030\220\222\277\026\255\335\033\364#\217\277<\370\324\377\324\340y?\361\273\375\367A\002q\277\026\374\255\252S\034\237\2774\220\260\023\323\310\252?\377RCU\300\365e?z\260\236\025*\342\261\277\024\224H\306t\300\232\277Cc\315\177*\363\235\277\3518\"\271Q\220q?\\x\353\233\334\273\303?\022\302\247\304\272T\244\277\350\233\335z\206A\241\277\322\027\324\r\251?\354\355*7s\350\230\277Y\331\336\312\272\335\251\277\374\227Y\300\273\t\267\277\371:\313A\207\350\233\277\274\367\227\305\360\377]\277H\r\332\273!#\202?\324\306\036\226p=W\277[f\322\366\220\034\243?e`(D\003I\227?\366\024\324\033F\333\275\277\240\360G\004\252\005x?\310\002\262\233NN\242\277\027\275[\027\225#\224?\267\350\317\211\346\262\245?\3159a=**w?Q\"\017\016dK\254?\335\030\277\204b\014\263\277\324\306\005\010\265\377\226\277M@DaV\327\256\277\320\244\307\220\272\032\253?%\177\017\"E\347\271\277\305\016M\375\\\255n?\346\364\231\212\277$\313\277(\255\253\301\300\031\235\277u*&f\005\205\224?M\022\004\224\363\302\233?\306\334\206F\316}\266?B\340\022qO|\216\277\340gt\263\231W\237?\207\027\026\023l\376\211?p\231}w\246,\300?\004.;|\375\306\247?\266 |\332}\277\254\277<1\236\356|G\253?\355\364\345\340\005R\253?\246G\301\016\256\234\267?\241R\016;\240b\235?\200\221aY\366\215\245\277Am\342+\213=\253\277\315\302\035\022s3\221\277alJ:\006W\306\277(\335\264\376\263z\244\277NB\265z@\321\212\277;\306\235\212\313\226\266\277\370\222~\356\343\247\257?\242\256\322\364\227\220\254?\305I\340\022F\304\254\277\nt\313\206\310A\273\277d\206\214Ht\314\204\277O\205*\345\361\215\263?\357W\222+rz\236\277\021\266\025\370\021\303\225\277\306\023\257\350\024\222r?\005\021\315Dm4\207?g\246\013W\374J\221?\017c\226h\204\353\226?\303\211[w\321~\241\277\031\020\000g\374\325\250\277\004\2373\235\240.\237\277\225\304\310\022\335Dh\277XG\336\377\364UM\277+G^%\006\223\316\277\345|f\303V[\247?\230\001\210s\340\257\206?,\007\346\205Ha\265\277=\007\246\216\260\320\226?\020\250\353\0100\236\271\277\226\347\000\325\222\214\270\277\021\264c*\n\037\255\277s\274\233\251\251|\275\277\367\007W\221|\347\306\277\032\261\371G~\377\301\277\035\204\325\320\007\245\311\277_\037\254\323\312\346\304?@\000\303\315\2133\307\277\245\022L\004\013\301\253?\244(\304\311\216\332\266?\274\330I\014\371\247\224\277P\360\376J\333\305\264\277\245\225\307\274Q\211\263?\264sG\311\342\212\243\277\202L\272Bi\000\261\277+\323\036\343\027\226\231?P\370c8f\377\301\277\371}\222\222q\254\254?v`\226F\220n\217?\257\253\327.l\213\264\277\352\224\304\315\2111\242?=\362\nb5\003P\277L=\232\233\022}\273?!\362\353\"p\251\200\277\026x\032\355*\306\305\277\264n\372\006\016\226\267?RA\235?\246f\300?\273\322\025HV\266\260\277j\000\274\356\377 \227\277\336\370\\\213$\257\266\277\364\277\001\002\tl\205?\372Q\344\321\234\371\253\2779 \260.\354\277w\277Z\002\005cL\322\300\277H\177(\267,\251\221\277N)\350\210\372\215\260?\346Q\236\020\355\366\230?A2\323\177\002*y\277C\212t\247\201\226\224?\"\364\347A\316{\260?\201\0379\322\3143\227\277\345\016PG\026j\267?yX\"\251\002N\241\277\205\025\254L\356\342\264\277\360\221Rt\251\330\264\277\234\0019S2\327\263\277X\036\361\370Qf\240?^\274T\257\346\322\207?\355AoqZ\303\206?\276\300\245\003\301\213\250\277\023=*\267\267G\207\277\004\361\320\240\273\210\261?\254\233\313\200\307\346\273\277\263~\201\r\361\373\215?\243(\245Z\023L\270\277\314V\343!\277\255\245\277p$\035\226\276\341\223?\357cK\200W\247\260\277(\370\332\010=4\276\277tp\245\034\222l\266\277\203\356m\211*L\242\277\010\240\013\r\356\267\263\2770y\020:\323\223\265\277\267wi\307\347\r\257\277\"UL\250\345T\256\277tm\025\305\320\242b?w\037\0147\245\021\301?qHx\206\213D\266?\342\343\375WY^\277\277j\266B\274\020d\315\277*\006X\20731\274\277\342Io\207F\374\201\277\'\020\215\232=\254\226\277/\352\244\003\301\242\224\277-a^\254V\320\256\277\r)\341\336\321\337\230?\264\365\033x\2055\251?1&M\2457\244\263?\301\312\001P\215L\227?;[\325\323\227\264\240?^\361E\325\222\212\235\277}\017v\202\271\246\233\277\264\345\256\247T\350\243\277l\\\"\376K\225\220\277<\227\223\025\347\317\233?\315z\223\361@\353\220\277u`\334\327\275\217\266?\200(\022+ 2\226\277Rif;\014\352\245?\002\252\212\304U>r?VYj\233qj\203\277?\334\367B\\\276\243\277Xo\030\254_\335\243\277\366\322B5\224\357\235\277fQ\"\324\274\036\252\277\023q\226\214\253\203\216\277\315iX|V\323\247?0\357v\260\214\310\273\277\237\'1\225\036_\262\277\332,\023l\325}\273?\031\305=\002*@\307\277\016\303^V]_\313?\376\010A\006\205\010\265\277\374\006)+\024^\230?\251\243@?c*\202\277/\277z9\330\365\274\277;\341\2105\"\257\241\277\322\317s\020|>\203?eMK\321p%\273\277\206V\003\037\244{\232?\310~\306\372\340\252\217\277<\\t\240\217L\255\277|\372\010\004$\025\233?\245\251\225;\034\303\263?N\205\361O5\257r\2779{q\353\277G_\277\017\362\343\321\332y\203?\315\342\310G\'\274\266?4\021\300\257Cd\232\277\244\376\004\341\324%\236?\300\354\321~Y\376\232?Nx\236\026\253!\242\277\036\025\\\264\347\234\265?\005\352\331\037\276\334r\277\300\235\370)\245\\\223?\236\271I\346\237h`\277\206\234\363CdU\253?L\236\331U\336\243\260\277\362\215\2314f\312\242?h\243\r.\361\005\247?.P\362\022&\223\270\277N9\311g\237@\203?\274\363\265wjn\245\277\357<\343\211\373E\274\277\256r\366\207}\257\260\277\234\337\373\350`]\300\277\032\3001\347?\351\213\277\352\261\262\264Q\r\220?\210+.((\220\301\277\027\300\306\225\257l\214\277\247\301\333:\'6i\277\024?\311\221FA\245\277\013\315\031t1\236\214\277\322\312\216\355\237\261n\277\006(\333\347\312\221\207\277+\213\021\304\3215\261\277v\\:\002\316\327\215?[^\177K#\231\217\277\356+\227\202!\246\261\277\325\0244\032s\005\262?\221}\344\257\217a\261\277\243\372\357K\251\247\252\277\237\003G6\234y\241\277\260\020\337_8\244\267\277\3318|\003\324\006\230\277\317\313\344\224\357\376\273\277\370\261\316\357G\010\223\277r\306\021\035\023\030\255\277\014B\343\315\360g\240\277\000\371\262\270y\317\255\277\352z\203\014\236d\253?\361\363\nC\203D\240\277\2530}g\346M\261\277\355\304[\255\206\332\206\277\003\252\234x\034:\230?Dd\373Dk2\244?/\352`\316#2\270?\256E\272=\033\r\242\277\003\304jt6Kx?\340C\270t+s\243?\001\030\211Y\203\'\240\277;\3064\330)\314\270\277\371\212\226z\313\037\206\277P\006`\323\253\275\301\277KP\rcP\021\250\277Yt\031U\361\247\220?\2102\235\032NL\245?r\361\260P\374\005c\277\223J\373\010\013S\\?]\335\367\036]\355\262\277\316\352(\024v\374\260?%rQG\251\325\247?*\244\211\336\215\220\242\2774\2739\020I\263\207?\213$\204@\215\253\272\277\242b\003\2162\336\271?\366\341\361\261\0253\222?\251l\370\233\"\311\243\277v\013\364\361\221\000\222?\255\271\220\207\014\034\252?\311\242\036\353\2105\272\277\357\312\014\345E0\254?\234\265\253T\023\001\261\277\177\273\232\376\333\353\214?\035\264U\3067\250\222\277\033Q\212i\344\226s?\312\t\003\333\341v[?\026\342\035\355\242\032\257?\266\331u\r2q\202?_^\274$\257\371\266\277PF\272jX.\254\277\255\275o\222;\202\213\277\316gVX\303\"\273\277Y\023\253\252\207\327p\277UX\317\244T\034\220\277U\014^\255\221\366\267\277#\304\231t\274U\215\277\272\n\311;/)\261\277\256}\232\276\3211\273?$P\266O\241zj?\t\253\254\006\250\210\252?\"\271\353PZ\311\265\277o\300-\0043\367\254?]l\202\311\354\275\264?\274/\026|zT\261?\"\375M-\326{\310?H\346@\377\343\334\246\2774O\203\366\214\301\211\277\244\345\275\'\344\223\226?\316EsG\266\322\234\277UM\255\261E\'I\277jW&\0208\355\246\277\343\243Y\032\n\347\260?)\007\306&\254\223\252?]\330\353\033\260\365\222?\344%\233KHO\260\277\303\254D\020]Y\227?\341\375\276\342\305x\202\277\204z\315\334\360\256\241?;\366\014\031Tw\244?\370\366|\023\025.\243?\332E\241G!\243o?\224\244wD\343k_?\373\272T\335fI\223\277\215\374@\223\350\331\223\277\356&\247\220\270\265\265\277)\023,v\370\343\247\277\002\351\307\372\000i\263?\204\037H\263\036:\267\277\353\244f\233\240W\264\277\305\034@|\300\234\222\277\324\340]\241\211i\232?\201\256\3617\270\332\264\277\017\3140dv\221\272\277\204\226\361\330P\236\247?\272\215]\005m\016\256\277\365[\242O{\371p?)\016U\223\'\320\237\277\354A\370\t\312\023\251\277\026\216bu\215w\222\277\'\272\366,jj\302\277g_nJKS\226\277\251\200\357\250\326\377\214?\266z`t\356v\266\277\267i\1776w\363\242?\356\236}(oX\254\277G\276\022\257;\224\262?\255c?\"\367\003\264?\"\322|\013\320\027\246\277\233\370\221<\264\364\237\277\327]\311o\331\017\221?H\323\030\230\216\366r\277\226\253v\035%\201\204?)\343y\353\037U\200?\220>\003\327\336\244\274\277\374\337\300f\002\254\264\277nK\274G\251\335\264?\330\271\330*;J\241?\342\337\032O\0043\206?\216\024;\214\306\255\244\277\277u\370L\207i\304\277\236d\204^\242\367\230\277\255\010=X\222\005\177\277\331\315\"\034\037\256\252\2776\027R\025\210$\235?\001\231\341\346qe\231?~\310\277biWz?d<\241\214\336\234\230\277C\363\325\305mK\243?\330\250\345 \242\032\245\277\342\237\264\350<\377\253?\347\227LE\216\225\242?\264\027\244J`\347\263?e_\221x\251S\216\277\020\366Z\272\213\336\234?\304\225+\'\350\025\243?J\313\354;b+r\277\267\224]\212\225\345\245\277N\243\373\255\351\000\225?a\023\023\306\345\017\245?\263\200 \270b\325\307\277\345\336\250kQ\\\244?\346N\201\204\021\021\201\277A\374\023-Q\210\301\277:\037\r \2231\227\277\337k\312\320\222\221\272\277\2431\301\267T\364\262\277\205\'\264\224a\177j\277\253^D1*\263\266?~\371\266\036\237\374M?\332{\364\265lI\203?\315\240\300\331\333\337\223?\302\346\262\002Op\245\277\0065ik\360\337\223\277\017{\257\263\263\004\266?o\233\310\261\264\363\271\277\212\371m\301\006\317\265\277O\366\265\260\354\266\273?\2112\371\247S\233\222?\034k<\200\024\177\235?\227\346\350V\366\210\223\277\350\310\021\372!W\270?3\204\351+R\346\264?5\374\255\000*o\306?\034\321y\232\271\225\250?\242\027\032\340\230`z\277\240\344\275\372\371\343\224?>\376oG\3201\177\277\252\227\207\250\345\200\273\277\006\274\035\206\216EX?F\363\223aF&\200?\211\205-\203.\313\233\277\263\330\242n\244v\242?\242\'O8O1\265?##\354\273?\266\277\277\320%/\342\372}\243?\300o\200\210\376\203\251?\217\2555\375\261_\264?AGZ](\273\225\2770$lnq\036\262?\t\312>\377\363\365\262\277\205\216U\216\033\354{?9\254 \216\267u\260?B\245?\n\330|\303\277\223.Y\333\334\036\240\277\207J!&\225\263\263?Z\205V\233\353\352\266\277\215Pl+<\354\245\277\275\033\376+\3270k?a\320\331D\354Qq\277\r\337\036x\261|\207\277\301\201\223:\371-\250\277;\315\026a\323\263\246\277\262\323\037\204\204\343s?U@~IT\024\236\277\372\354\201`\316\246\230?lA\212U%\256\266?\313\030W\022\034Q\276?\251\204&>\215\341g?m\324\260JP\362\234?\026\347\036\354\312\302\300\2773\250+\244\314$\202\277`,\374\243\303-\257\2778=j:[9\260?7\245\035_\300\204\215\277m\316\203\246\265\014\274\277\tJ\231\021\211He?\366\245g\242$\314\253\277\220\037\350\326]\276\214?$V\022\243\032\033{\277\006_)\240y\237\220?\320R\254\215\r\300m\277\022{\303O8\301\246?lN\265%O4\267?\340\\c\221\235\262\244?\240\201.<\276&\231?\374\334\360\322\360\346\247?\326l\2434\232\372\244?;\017\364J\005\022\230\277_\257\025\227]\311\200?\013\002\375\006|^\245\277\352g\342i\251\273\205\277\3513\273\201\361+\205?\202\213 \337\375\267\303\277\317\231\017p\361\304\246?R\255\244\304)t\273\277\024\262\213U\361\253\245\277e\217b\233N\216\243\277\223\272\247}WQ\220\2775\250\223\260\310\311\231?\001\026\264\361\274\216\212\277z\3112\234x\001\232\277\302[\003\325\221z\237\277tu0\212\332\310\250\277!\\\254KPt\242?\213\326\216\200\201\317\254\277\250`\022lrK\221?N\230M\353\205\262\243?\272\t\022\331\0038\210\277g\225\305*\310\245\203\277\241\001\t,x\025\241\277\'\021\310*\352\t\256\277\372\355\372\251\303\352x\277\001\251\236\030\340\325\264\277\014\221\330\342\3657\311?\227t\r\252w\313\237\277\312\331o<\016\317\265\277W\002\217\267\315i\221?=\317x\000k\362\242?\242\010Ifl\230\224\277i\305,\017\005b\265?\311M\321F\375-\226?\321\217\341\240{7\253?\246(\344aA)\321?\215\340\216c\020b\311?\335\312\2538\031\030\305?s\340\340\376F\332\270\2775\361|\301\325\303\255?\374\320\r\003M\251\261?#\335\235\266p`\250?\265u\221ww\300\250?\370\362\356\335\356\347\271\277\333\243\350v\005<\240?7\343y\343(\356\222?:$\216\200T\206\301?\376\302\241E<\323\205?0;eJk2\246\277\212\025\224h\254{\303\277`C\220\033\331\300\245\277\265\350+.6\375\271?ag\313\304\254:\277\2770U.e\306\276\273?\177\337\331\237\240\357\235?B7L\377\351\276\242?\332w\307\004x\340\223\277\201\347s\317\214\241\273\277,\"Q\317\222\357\230\2778\311%=\333\276\204\277\000s\374G\353\360\253?\303\271\250c\006\272\245?\326^0Q\2124\243?\230\215&\345\350n\262\277\000\316\256\276\004f|?\016h!\030\362\335\305?\350\307\024\261\322\232\234?\322\231GM\330\264\303?\344h\362+]\200\224??\035#~\026\223\214\2777\002!~\273\202\240?\005\324\312\251\260\311\243\277\200 Qr\304\314\250\277jfp2\3408\246\277LQ\030\216\212q\252\277\224db1(\210\211?^2\306\322\333\225\205\277i7t \250\343\267\277\002\206\177E\347\374\236\277\203\354&ZR/\240\277\263\312$\376\t\032\232?t\304\304\342Ju\222?\364\277\223\342\343q\242\277D\025\347\235\251\304\275\277a\0167 \370\240\314?\020~[+\001\230\266\277\256\334$\363\362x\245?\365\364S|\315\332\252\277\\\271@\370_\266\263\277\"\002\025\307\225q\263?J\315\350\\\337\024\260?\331\002\246\246\245\327\265?#\240\303\372\303n\253?\210\241b\032Z\362\263\277f\241\306%i\347\273?jg\271\230\036!\247?\326\267\031c\033@\247?[\220\310\260+\'\201?\314Q\362mR\317\235\277{\010\223\356\014\000\230?B\036p\344\240\004\251?\032\233P>\217\271\302?\256\"\200\235,C\302?~\\\241\'$P\252?\253r<\262rx\264?&X\244!=\370\265?u\177L\317\373,\243?\245\231Iz\006\245\271?\273\316c^+\322\256?C\334d\\\016Z\222\277\301Dg\034Vz\227\277\361\004$\375&\302\263?(\025V/om\245?\355et\214\301\001\250?\276MzJpT\230?\342\022\361Yb\330\245\277\264\224\247\177\327Z\207?\267\356e{i\257\240\2774\303\037\266\360\375\240?|\330\025\300\3777\211?m\274:>6q\230?\236\002\304Up\256\237\277\207-\220\347\275$\250\277Db\027K\3528\225?\274\366\223c\026&\275?{\355\240\332\254u\230\277\353\331\006m\272\312\273?\277\"\277\001JZ\232\2779\356\037$\355\275\231?f\"\212\224sV\303?\275*\201\333\366}\254?^\273\336\213O_l?\004\215\306\227\200]\245?y\'&\326W\244\314\277H\021(fQ!\317?\016\231r\024T\030\275?\315\202\0135\301\375\263?\035\250\272\332\r\370\271?\020_\222\r\014\025\254?\247\261\330\\_\027T?\343\222\221\314Ah\313?`\265\335 \356\030\236\277\266o\242\357\037$\230?\242\221\216\320c\274\220?\242hgbM\206\241?t\334\026\255}\344\222?k\354<\341i\326\234\277\3573\320\362\0353\251?~\311\263\375o\354\212?h<\200\230M\362\262?\366\206\223\3026\014w?\234\361\227\342\020!\257\277\341\220b\331hL\264\277g\334\376,5[\237?/-\300\260B\r\260\277\030\325\273\316R\205\212\277,5\271\315\035\361\226\277\2576Y\013\017\025r\277\244\341\010\357\376\315\232\277 \371\322/\373\317\221\277\262\220\227\354\322\003\240?*\211\221Hd\020b?;I\325\000o\020\264?\376u\327\033\020\323S\277n\005\277\345\014\377}?\2358\260*--\210?\277\254\007\016\243~\234?4\305\\\374\032\004\305?3\022\331~\356o\235?7\326\237\223)\260\247\277\256\364\366\345f;\247?\363\014=B\260!\253\277\316\026\357\376_+x\277\340K\211\252Y\240\263?\346x\371\004\335\343y?\302)\335FLy\237\277\013<\372\351!z\247\277\336X\027k\252\343\206?\373\020\035\236K\362\254\277\367G\346\232\033\234\255?\236\031\t\333\366\377\231\277\330\223\353\245\\q\211\277\016\271\3071Q\355\272?\273\336\203*\017u\262\277\343\336r\302n\331\240\277\\F\363+}8\306?\364\202\213\324\027\354\257\277H\007j)\303\221>\263i\243?\267Yo\330T\326\267\277!\261\335\300\347\212\222\277\025-Z\250\002\301\261\277\375\366I\354V\312\240?\331\233i\360\361\002\270\277\327\'~\274\375\341\227\277\222uY\327\257\360\254?\306\332\370a\365k\302?\031\\\230\242\211\265\240?\254\3229\317LZ\315?\355i\201\331\215\217\241?s\274P\2337\013\246\277\0106\354\002\004Qa\277\263H\346\236+\026\237?\330\336\031d\234J\234?\021\367c\242G\311q\277\301R\254\230I\306C?\336N\216WjB\232?\233\3668F\231x\257\277\356x\360\331q1\256\277D\036\331\026\324\227\303?\325z,\002k\020\246?\302\234X4\322\265\223\277S90&FX\276?]\250\233\0210\200k?[\344L\010\374\366\262\277\305\000\367M\365\214\300??\247`\204KI\307\277\262\306\366\\\271\274s?p\355\'\211\234v\236?Ug\006\341\227\247\271?$$X\267\031\002\254\277\267\360\223\211.\322\264\2776\320t\276\245\312\260\277\006\245T\223\300\241\206\277#*\017W\311$\254?!\025\334\305\317\337\263?\3119~\035\356\204\262\277\235\021\330\230\232[\252\277\220,m\347n`\212\277\302PoT0V\245?\2402]\336W\034\275?\232K\375\275\332#\213\277\016\252](f\224\232?\331\344\r\345\233\210P\277\230\3440d\353nm\277\207\032\222\027\334\031\277\277\354a\221vC\034\263?9\256\360@AEz\277\"Q\254\323Y\n\240\277N\220\030\037n\021\277?C\244\372\270$\257\314\277\024g\362B\204\341{\277\003\353\372\327\334o\242?\256Y\tq;\347\231?\024\n\020\360\332\201\275?\203\376\001\363R\353\265?E\237N\0201\344\241\277Z8\250\233\336;\251?\363\230\313\366h\235\245?\360x\221\2427(\231?>\277\016@.:I?\370n\213\024(\265\303\277\376\300\372\272\034\266\266?\313\302~\202\245t\251?-<_\376\027\273\221?\240\313\r\333M\025\244?\241\331O\305\346\006\233?p\267s\241R\215\246\277\374\335\314\231\361\025\305?\240\233\224\307e|\231?\312\030\371\206{\263\304?\\\177\367\257wm\241?*\204#.\320\242\242\277\353\200\221\240\306\316\236?\347@\371\035S\306\266\277C4(\026\225\305\242\277y\270\001\351\327\353b\277bA\226\020\254\266\274\277\331j\247\022\202\310\253\277!\275\255\024\302\013\251\277=\016\036\321\211\017\231?l\340\341!{b\223?\023\003\376;\t\253\222?\307\342C*\320\230\230?\037\263!\371\222.\217?\345\236\202y\rm\323?u\253\214\225\327\016\230?\037\271\235\370E\336\233?\271\255Qy<\325\273?l\246\203\264\367\253\223\277\302>\036\364\360u\271?42~\206\362\275\305\277\346\177\257\370\356\366\215\277\200\316\300\261\016-\233\277\377\326s\"L\221\222\277\027/\325\027*\247\260\277x\021\356\215\030\312\221\277zA~\024>\222p?\002\361Y\036\017S\252\277\r\271\301\'b\225\264\277Pn\000\212\321\024\257\277\330h\247e\027^\250\277\233\360\312\302\003\355T\277\344JOc\231\273\246\277u\205\334\362\3552\241?\350\304\225\302\016\250\254?9$\370\355\217\221\203\277\023\242\367\242\236o\252?\261S\034\240\346\007\270?\215\357\2218\320r\244\277e\2724\027\370Cv\277a\013(\313\313\375\257\277_\024\214\331\304\347\260\277\305\274\2660\306l\262?\216\232\216\343\304\320\260\277\033\007\240s>\233o?6\217Sk\277\201\236\277!\366\373FY\310\262?]hV\237Y&\263\277\340J\362X\356\233a\277\rR\255\217D\035\223?Y\007]\264\346}\226\277\002lO7\'\277\243\277t4\356\225\027i\211\277\262|y\344\r.9?\276\326\226^\256\343\320?\305\221\373\244\375\265\274\277\206\206j\314j\\z?\251\375\366?\336i\250?\241E\313iS[\246\277\243\262\'\357%\310\300?m@\301@\367\347\245?\310)@N\301N\256\277\322\310\215;R\220\246\277\216b\263*\332_\275?\235\375\311y\316\n\211\277O\006~\351M\032u\277\350\367*M\014\314\225?\016-\010\217w\244x\277v#\n\305\217\341\252\277\365\365S\216\372v\253?\301\336\253\300\260&\234\277V\267iW\363J\264\277{I%\020\264\252\273\277;yc\300\304\033\270?\226\215g3:\030\306\277\224AE\343\231B\247\277M\003\361Sz\177\246\277\204g\270\300x6\277\277$!\016\226\220$\245\277\220\317\0227\2271\241?\255\\W\336|\307\250?\355\013\225|<\035\363\276\347\363\031\304\221\234\200?\201Uy\016\245\234\266?\335\213\262U\037\311~?\r\344\264\317\361\343\240?(\251\002\320Y\300\264?\261\322\335&\2559\266\277x\345\235A\013g\241?\264\355\343@8\276\262\277\343W/ \321\220\225\277z\037\327\357\005\376\255\277/\024n\230\377_\267?5.\225\362+Y\274\277\335\277q\344\253\030\263?@B\177\016Q\036u?\241\232\230\233\214\356\222?,\322\3302\027\237\263?\207\250\221fd\224s\277\216C\370\250\362\273\237?\312\023 \024\364\301}?\313\331\342\014\213\241\216\277\265\242\351\366\243\037\247?a\2418\245\236k\261?T\201\030\372\266\211\224\277\376@\214f\026+\247?\201#$Oc\335\227?\250\203g\327\343\262\203?\334\200~.\247\246\253?\275Bp\212\305\232\257?\376\270\341#fu\251\277\014 \003t2\340\206?\310\n\261N\233\322\201\277\000.4\022\362M\236?)X6\262\367\224\252?\366-(\235E\212\222\277ob!u\ns\242\277!H\002\333\3332\224\277\235\300\352\340\r8\237\277\272rN1?7\240?\200P\322\n\253\260s\277\033\255}l\343+\221?\204}r\302\340Tx?`d\17785\021\247?\360O~|\270\r\250?\213?\0373\207i\257?G\271,2\226&\253\277\201\301\342\200\347;\303\277\336\305\013\306Tx\214?\017\352\344\177z6\265\277F\211\303\334\2228\245\277b\201\266\004\333\243\220\277p\252.!\235\364z?@\2354\317\0220\256\277\327~\211\375\352M\272?\342Y$5\374rj?\206\320\2562\313\300\255?\215\244\272\345\250l\312?\325\370\313J!|\237\2773eLM\331\325\260?\'\305\305\024KG\262?\260\322\333\257\314\327\233\277SKm3a\021\271\277\006\340s$\357\211\261\277\200\375\267T[\211\215?\323\313\343\322\203\355\237?W,\276sz\204\276\277\277\271\000k{\"\237\277\207\260\030\342\3645\242\277|c_\276\203D\261\277\032I\213\030v\304\244\277\244\300\013\027\206\313{\277i\217\242\230P>\223?tL\032\243\355\203\235\277\347\010jv\273$\252\277\374\2577\354R\nl?\016\316\2472\rZ\224?\275R\216cj\027{\277\251m\021\265\225\235\303?\343-\376\252\023\202\274?\014\253u\221\272,\224\277\360\n\222\274\313g\256?V\017\223nB\246\246\2771^b\375\330\023\260?\216u\326%J/\307?\002\037\320\036}5\221\277\003\300\324\204\000\250\242\277p\331\306\'&D\304?\305$%\217G\361\302?\340%\234\'`\243\265?\223C\230\002L\371\251\277[\200\007\257\275\226z?\206l\021\027\213>\245\277\341\035\262\375X9\261?\256\217\033>\205S\263\277\243\016\224\037\346:\243\277\325\356,\327r\325\302?B\320:\006\233\221\264?\266\311\217;\216\343\265?O\005\203\370)\236\247\277\343\t8\206\312d\222?!i\237r\367\344\241??\240\302B#\242\215?\034\t\351H\302\302\270?\204\340d!}\263\235\277\236\211\230\301\020\002\204?\363\304q}\027_\221\277\367\234\371+T\372\261\277\270Y\342\256\242\021\240?\317m\325\245j\n\262?%p\267\236\024\373\307\277\232s\325\223C\355\240\277\330\233\004/{X\256?\032\254M\210\027\\\264\277\037\014\347\324\323\245\264?\304\360\215\361O\351\230?\021\251rfi\271\243?\342 \212\323%\213\307?\000\2731\354\355\365\207?\232cM\"7T\270?\005E.1\350\321Z?F3\303\037\204,\257\277WA\212\252ni\241\277\026\372\320[\341\271\263?\205\352\021l\353\335\240?\325\377\207\3160\002\254\277\366\242\244\330s*\241\2777\017\233\344[{\\\277\305<\2625obb\277!)`(\270\321\224?\307\325\320\021\317\371\250?\260\264\304\347~\256\221\277V\3027l\354t\023?@\270\177\034*\267\203?\363\020\253c\265\201\267\277\000\014\312\330\321T\201?\002\371^\267F\344\302?\003\322M\262_\232\256\277\356\177\350\"Hu\261?\367Q{m]2\241?3\370\327\350\236\270\217\277#\037\275\016\325r\261?\274d<.\004a\312?p\225o\342\000?\277?\216\220eO\353\030\260?\342\200\312\211\340\225\261?\3270\254\010Vos?\211\256.?%\005t?\330V&\321\363\230\265?\320hL\032\363\331\271?_S\331\246\214\271\256\277%-\342}X\200}\277>\252\300\020\323~s?)\332\310AX2\300?|\265\001\021mj\272?~2\030I\226c\267?\275\033\311\247\2174R?\004\311\277T\301G\207\277RZ\275)\260;\300?\tDM)t\225\222?\222\373\323n~x\233?\025\210J\364\265#\202\277\226\236]>\206\224\241?9\367U\335\314~\223\277\251-5io,\207?\210\266S\373\313h\243\277\370\203s\361v\227d?2\210\277s\003\306\230\277\r\204\016\342K_\233\2774k\355\241=\263\220\277\266\332*ql\267\264\277 s\324m\203u\203\277\261\272X\321P\004\264?s7U\n\321\024\257?\304\250\t6\312\341\300\2772\037\216mh\014\203?f\010:\364x\256\267?/\\\255Bs\256\207?kcu\330p\272\270?\347t\032\025{8\235\277ta!f\230j\276\277\037=\032\325\3504\305?\206k\236bt\034\234?\000,\235|\327[\254?DP\2274U\350\244?Y\341\003\304\266A\306\277\241\343\273\013\373\224\244?\231wL\320\371\275\232?\331O\'\000\320\213\253?Vjs\215l\332\260?\340$|\262\331\357\235\277\234\315nI5\272\263?\373\252\227\'__\310?a3S@\265\023\257?s\315\303\351]\371\212\277{\r\027\007\316\316\231?X&\332\270\347\177\264\277\3408>\352\036\321\265\277\200N\211\t\277\010\251\277\\\276\366\326\032\217\220\277\250H\222rl!p\277-,\213\351\322\271p?\r^4\225\034\302\220?;\315\225\345Z\210\227?\005\252\0319\232\265o\277\326~\n\027v\\\254?\006\212\220\366\243m\235?\352\276D\360\246\204\241\277\222Z\362I\337\nN?1\021\376n\255:\260\277u\304\273\261\352\250\236?\311\255\034\333\005\037\244\277\257\231Y\323]\304\243?\330\021%K,\347k\277Xj9\030\336\301\253\277\014\311\271\351\273\177j\277\254\373\t\016\274*\270?>\270\257\244\340c\260?\343\233\2235T\232\257?92\354f#7\302?\254\3265^\346\353\255?\232R\3107}M\240\277\007g\312j\343f\253?+\214\002\256K\256\261?|\003\016\031\230\351\251\277\004\342\034\336\321\014\237?\200\007\273\032\322d\236?\237\3111\320\000\013\243\277\315\002<\210&C\246\277\3520wp\033\305\207?N)\231\361 \351\236?\004\346\352f\031\220\272\277\345n\031\235\277n\225\277\177\360\t\305\\\031\264?\362~\306\ty\243:\277wI\316\003\343\331\245\277\010]\273\033\272\314\207\277\364\207y\312\024\036\276?\300P\'9\377\n\250?\237\313\371\346@7\237\277\201@\230\271 \221q\277Ot\n\220\t\364\247\277B\305\032,z\350\234?\353\315\205M\353\206\204\277[\223z\274\307E\252\277eANQ\274\014\234?wVv\241<\001\243?\335\366\030Z#8\225\277\037\3321{}\234\223\277K6J\235\005\274\202\277\3635\242\243\204\037\213?BE\212\210 @\227?\250C\371\355}(j\277:o\220\313\310\200\260?\304\276\025\253 \236\234?n\225\253\200e)\306?\013\002\327\354=\276\302?$\016\013\364H\267\300?\277p0\202\234\365\264?\005\313tV\014\315\244\277C\r+\356\334\303\231\277\031(\206\3070\037\220\277,0l\314\017\221\244?\020\230\216\325\263\346\272?O\020\t\237\311\272\217\277K\364\006P\356\246\255?s\003t\004w\231\242\277\244^a\2123[\203\277`\n\366!\335<\232?\352\036\217n\335}\263\277\354\267\310{U\250\255?\317\t\204\361\345#\257\277d\021]\222=+\226\277\312\270\350\225\364k\261?\255\021c;\360\306\301?\013\313h \t8x\277\355\270X\336\247P\257?\213\372[\241\331\274\260?6bY\211\344p\221\277\262\343\014\274\234|\277?\364\001[f\243\013\245\277\325\351|d\307\214\260?\326\315\3715\2009=?\345/\214WWI\223\277J\204\234\367Us\224?r6\237\305\203\322\216?SJZ\274 ]\247?\262{\305\032\0279\247\2772\327\035\3377\035\232?\025Am\342\342\313\257?\377\250:|\220Q\237?\336>pA\322V\205\277\027\205!:\020tR\277\274\354A{\r0{?_Uk\245\2640\274\277\346{G\215)C\275?\231\330\361\266\024t\227\277\202\002KT.\016\260\2776\032\002\033z`\253?|\222\206\251\222\201\266\277#\350\355\225\225\005\230?A\265t\005JXa\277\367S\232oL\366\247?\004)(\276\367\321[\277\023<\215\030\236\031\262\277eA4\030{*\243\277\007Oe\275t\303z\277\207\323F\320n\353\277\277\222\362Yw\204/\247\277\004\313J\025\256\201\220\277\322\307\343\350\272\341\201\277\214\245\016\246\302\247\235?m%\324\203\332\342\206\277H\340)E\327F\232?\031|\373\277\336\355\243?\\\247\273\242ge\226\277^\251\332\221X\330\241\277\220\277!\032m\203\220?\023t\243z\\\312\242\277\272\272\374}\270\210w?.k\213\n\326{\224\277\027p\226_Z\206P\277\246d\2273\262?\261\277\254\3659\254/i\251\277\313\2748-d\026\224\277\241\240\242\310\315!\270\277\315\304\213\034\240\264\243?kQ\306\031~\227`?r\245\363\374\027\316\246?\336\004\\\322\361T\261\277\333I\207\273\341?\233?\177\202L\343\231\302\241?\344\370\021\002\260G\264\277\003\234\264O\006\205r?Y\317Vkj\351\310?\002J$G\017vl\277>\267\347\037t\352\213\277\277=\263v]\n\254?\221\017\257\305[AZ\277Rx\360\353Nh\200\277\306`f\357%\037\225?\315\026!\371\261e\252\2775\350\023\031\032\236\257?F\022\316}\3012\304?\257\255N0^\306\262?(\275$:=\325\204\277\254^\370\021\0011\220?y\026\277\222\337\310\247?\252\316l;X9\265\277\261\347\332\233\225:C\277\031u4\370\255F\252\277qv\345u\032\330\243?n\rc\267s\320\211?\t\004\247\205I\340\224?\202\200\007\362\362o\261?n\345>\367\033U\250?\326[w\332\223\035\246?\324\224\032\371!D\241?\004\260\330^r\255\205?\276N\314\272\346\302\244?\302\215x\313o\241\224\277{\376MMy:r?\3074Q\324]\230\231?\267\310L\373Ul\264\277\254\254V\271\211\260\240\277\220\007\216 \037\305\245\277@\310xA\303r\241\277\005t;\301\311\017\212?Tb\331\275\363Q\243?\213V\225\035\321\031\262?q\033\312m\260\201\234?\333%\017]\345\232\200?\337\362\3013\266\340\\?\321\201}ALf\211?\016\035ak\371\262\272?\234\237\2323;\206\242?\2342\353\324Vk\201\277v\365f\035\013\226\252\277k\220\204\035\277\260\207?\346`\332a\245H\250?\010i\343\317\324v\255\277[GHr\327\037\221\277:\375\200\323%(\256?\006:\325\346\232\300\257?^Xb\271\334sb\277\2605\031\365\307\002\266?\013;\252\313t\262\235\277QZ\227\325!\037s\277\270\342yr\020S\250\277\271F\373\270&!\240?\261\205\317\372\304\347\201\277\325\244i\266\330g\235\277\215\2659Z\034d\247\277\303\275\'\343Z#\266?S?E\214!?\277\277\034?s}J\215\300\277\r\365v\365\037*J\277\351\246\305hvG\301\277g\356\n\002\331\254\222\277O\274\354\251\231S\240?-\253\223\\\324\215\253\277\032\033O\233\315\026\223?\326W\305M\253g\237?\266$)\2777D\232?\370S\023G\233w\231\277q\000\010\367\241\367\263\277\236\245\375d]Z\261\277qF\214\327\2202\240\277\310\021\223\256\200\351r?r1LE\326\210\271?5\276\035[\355|\255?\316 \207q\325dn?{\n\367%\206S\225\277\355/\024\330!\242\212?\343\304\252H9zw\277\016\2779\226v\345_\277\312$\230o\201Y\220\277\251L#\314q!h\277=\337j\362\346;\231\277L1\306f\"\356\217\277\250\267\376\2428\326\261\2777k}\215k-\303\277Z\204r8ixe?\362j\203i\223\306\246?a\220\031#\357\037\241\277^\230\032.\315\310\225\277\235\265\005\251\016p\250?A\273\214\3420Z\203?\365ntZ\322$\260\277\201}\303\241\301k\210\277>\006l\347\374\340\207?\3511\020\227\346>\247\277\202\374\212s\277\013\252?\037Q\035d\376F\247\277\336l\217n\325\253\253?x\366EE=-\223?\273\242\257]!\366\263\277R\367l\234,H\247?\343$48\006\313\220\277\305\337\242l\2571\275?F\375\353\360/\214\235?\220\337\333\034\302\020\245?\350\201\330+K+\270?G\267J\020\361\351\240?P\020A\374\327$\263?.\352\323\263!H\255\277\247\276\222\260s3\251\277\352,r\036\0134\262\277\206J,t=\270i?e\020.\274x\035\242\277\272B\214\022O\010\264\277\355\353\250\377\320nu\277\373\"V\343\006\207\250?\214\017\332\013*\220\220?\221&\324\261\227T\274?\221*\313\323\336\241\216?o\2274\272\030\322\242\277Em\244\376\021y\305?O`\300\326\307\373\247?B\211\265\211h,\261?\234]w\037\235\356\233\277K*\237T\034\274\201\2774t\374\027.\302\243?.\245>\256\206\212\267\277\376?r\333\316\014\252?\256\270\364\024\233\321\301?\227\016\3147\256\213\214\277ex\247U\204\300\241\277\241)f \347,b?.%\177\2343\271\241\277\366Q\304\277\221\010\247?\035\315\214q\236\304\211\277Pwz{\317\300\242?Y\377*t\251\024\233\277\246\034@/\233\032A\277\'!_\310[=\241?\323Q\006&\307&\235\277z+C8a\345\256\277\000\204\312\214\005.\300\277\036\\g<\273\027\253?\030\374a\220\353\234\244?Q^Z\346x\202\272\277X\324\316\321\227\247\247\277\241\016^\034\241D\231?\276\231\312\330\240,\301\2772%He\223\025\241?W\215\345\253\217\351\217\277\327\322\301\324^\203\316\277\331\252\3436q1\301\277\201\273c\350\340<\305\277\2060\013:\0077\301?\375\354\004\335\030\177\230\277\326\215:G\253\310\266\277N\352\373\221\003\025\177\277(V\263\255\303\310\220?<\245T\3527\003\225\2776\252\345Q/\221t\277\004\022E.\252\300\235?\360o\270\276d\201\272\277\220\221\302\032wZk\277\262z\263r\017\321\265?t\214\232\350\352\037\250\277k\336|R\333\010\254?\000I\330\003\247:\314\277Sa1?\245\002\303?c\262\243Rx\033t\277\361\247DN\003\215\231\277\314\307l\352\352\211\243?\202\236\223.!\273\202?\221\337\252]\315\323\260?\302\307\211\027\005\331\246?F\226\001JKO\236?\314\033\334\357\253\275\250?\312q\225\236\323\214\270?\300\000\005\356|\305\244\277i\033\006\340\310\356\235?5\177)\233\233Y\226\277\275\355!\274}\220\265\277\177x\014y\256Y\270\277\245hr\347\206?\204\277T\303\336n{\270\214?_\334\035\321h\331\275\277\207\203\240_2\231\221\277\220*Jx\324\372\244?&\255\223\252,\303\265\2779\263\214/\273z\222?\303P\364\235\231\243\227\277\022\227\352W\r:\241?\301IH\222\204\212\243\277\252\205=\203)\001\276\277y\373L\363\262\274\217?\3420\232\275^\345\252\277%\\J\377l\325\214?\177d\310,p\375\250\277y\201^\315\371\310\265?\014V<||n\257?\366\r\253 \"\267\240?5\213] \232\312\241\277G\201\257\rS\334\264\277EJ\215\001\373]\246?v\rg\361O\260\262?\337;\201\326e\241\222\277\021\367\326\335\315\210\264\277IE\3006$\017\267\277\367|\344\'\230\222\177\277#\243E\337O\231\255\277o\243\362\253>5\267\277z\270X)\212\245\275\277\217(B\277\270\322\242\277\206\224\234\336\330Y\273\2776\345\r\200\234Q\265?\267\334&o\230\334\254?\241h\004\233\2522\265\277\376L\345D??\303\277\360\035\007\007\206\377\322\277X\361\n9jN\266\277\377\207\342\245\337\225\222\2777\214\262\203`\350\270\277o-\341\002\016>\236\2779\203\341V\004_\302\277\277\214\345Fl\352\256?\215o]\177~d\240?\2727A\243\310W\262?i\203\253(\231\014\245\277\245\275vB\356\231\244\277\020\355\032\212,;X\277\'\202\026\254\032_t\277\031\035Ww\212\226\250?0t\244HgR\240\277Y\273\261\320Y\036\220?}\351O\014\270Zz\277\206B\367\014\233\304\215?\340\302D\35194\304?_\376~\235u\262\221\277\006\372\"C\027\273\211?90\230\217\315y\272?N\362X\002\304\200\276\277\2116\215\255\024\234w\277\206\034\013\006\311\016\240\277\004\337\346\315[\337\257?\361\323=\203\327\266\275?\350q\320*3{c\277\237\213\304@\204\251\301\277>\235\2262+\346\232?RxA,9\365\263\277l\301\373yal\301?^M=\007\002\342\265\277\313\005\237\006=\312\263?\347EM\2628\212\264\277\307\341\266/\221\227\264\277>\255y(l\207\263?\013\266{\251\336\037}?\215\372H\310\025\354\222\277\377\036d\301\353C\266\277\333\253\n\350\354\027\261\277\235\017\263\305\364\247\244?\017t\364\205\020.\253?\355\305pqelp?j\025A\205\254Q\262\277\277\315F5%\321\241?l4^\323\377\356\260\277\276\223!\230\275J\260\277\206\006\224\357\352)k\277b,\261b\035Qx??\0253Q\263\251\241\277bfN7\030\006\211\277cdY\276ob\211?3\251\010\216\260\372\234?<\234\210\312bW\211\277\372=\315\035J\362\223\277\024\245\377\030Z1\237?\270\312,J\035\311\227\277\257\231\223\343/}\261\277\320p\367\035\230\357\264?z\020Xt\205\352\222?\004\262\004\001\345\316\261\277\342iL\216\362\217\251\277\327\273X\037s\300\240?S\247mr\035,\232?\022\262p\'3Z\303\277\220E\201T\203\240\243?m\273\317V\351\273\253?%\272\n\030c\307\250?M/T\213\343\\\246\277\314IG\037\215\227\205?\372\265\370\244\245\202\201\277\366\310\n6p\037\250?\000\213\316\206{\260m?\256\3042\235#*\260\277\330HH\203\016\212r\2778\006\216X\273\240\241\277\376\206\325\374QT\231\277^\361\236B\025\003\232\277\376Pz\355\263\233\225?\237\351\332\371\206\202i\277\251\266S\334\'\201\302?\325\322\223\2008Z\227\277ZEo\307\005C\305\277_I\2533\207t\231?C\334\023?\207U\273\277\262\035\272\004D\301\221?\336\010\352n\320\021\226\277:d!\273*\227\233\277\032\0343\372D\222\241\277\035y\205+\212\216\227?\354\305-C\037\367\265?\303\336v\236\212\273\244\277\212\255\224s\032\240o\277*\256\205\006T\021\254?\275J^\002[\357\263\277-\276\315\027m(\267?\214\346\203\023\302\336\242?6\323^v\273\254\242\277\203\327\026b%\370`\277\300\325\270\331\260\263P?*\240\177\210I\264\203\277\027\365|\321\027\264\242\277\333ITUp\277\264\277\265bu\023\272|\214\277\204\231\356N\300\205\223\277\r\366_\246\030\234\264\277d\355\200~\033)\223\277u\267\301H\016\304\244\277\247T\306\324\256q\243\277\245\033\300\300\207\377\234?\257\037\260\371B\246\270?\230\215\302\241\346\276\246?F*76\263\322\222\277\200\230\277I&\202\216?\023J\376\324\252}\240?\' 1J]\316\213\277X\350\3548\332\325\261?\013Gp\326-w\263\277\2746Jp\211\203\265\277!=\270\377mW\270\277,\270\206E\212\366\262?2<_/ u\245\277\257\204\352\303=I\262\277\013T\'\377\316\203#\277\243\347/\0104\216\247\277\375\354Cj\340\201\243\277H/\\\354\216u\266\277\270.iv\306Q\253\277\323\275A\n\2516\234\277\313B\306\277\010\321\245?<\243\237E\376\375\211?\212\354\227}V\370S\277\242\032\r\310w\001|?&\212\004\020\\\352\250\277\277\203\022\332\014\236\234\277\222\212}\225.]\265?n\334\221\373\204\345\271?\251\230\036K\034\022\217\277K\225z}\014D\255\277p\227[\235\371!t?\302\206\272\330Ym\220?9-\303s\221\334T\277\372\214\244\323\rA}?.v8\302u\222\201\277@2`\316G\372\314?S7#|\341\234;\277&\226T\327\023,\243?O`%\375H\020\245\277E`\275D\267\023\242\277m\016\224\327\031\267\245?\255\366\3444\305I\260?\036\215\273t\377+\245?\346u\211\\\271\314\274?\376b_\274_A\227\277\203\224 <\257F\226?Ob\273m\317\003\240?8\032h\371}Y\240\277\200U\017\343\256M\226\277\337\237I\325\350<\246?\341\217\021\002\2243\263\277\354l\367\022\256\245\262\277\201j\374\337\353\242\200?0[\357\345\233M\214\277I\207r%7\021\243\277[\366x!\267\375\313\277\\@\241\323\202\207\250\277W]\365\233-\027f?\007\003\202\347\266+\244\277\027M\303]\250\342~??\211\205\371\036\022\005\277\324\320\204\206k\210\254\277F\223\000\326S\247\245\277\207f\370w\372\204\276?\242\345;O\236\236\241?\306\000\330\307\232?\252?z;\261\000:o\245?\207\210\242\231V\317\231\277#\003\352QZ\034\266\277\207\033v\370G\007\254\277_h\355|<\323\315\277\343\236JA{&b\277A\022\264\000\254\202\237?\204\241\030\202f\326\230\277\207&\005\242\351\235\257\277\203M\223\231\220\035\300\277Wk\202\002\306\301\244?\014|:4\202n\261?\342\271\235\rx\240\227?\347]\305\3057 g?p:6\322G\217\226?C\001\255\326.o\274\277\213\235\3273\246\366\221?\202\201~\354\353V\265\277\377\020i~\000\025\204\277d\364\251b\212V\211\277\003\026\217\2653\346\230\277\013%*.\307\270u?\263[\033\256\302{\266?\327\226\275SK\366\243\277\021V\0040\202\352\303\277\243\355\201\022\200\312\262\277\242\320Z\203\310\304\236?E\214>Dp\331\243\277\277XjJ\307\036\226\277\236%\376\203\231J\200?\003:\303\021\260\322\263?/\357\210-\265\313^?|\366aC\320J\224?I\217\372\031.\341\255?\254\317h\024<\373t\277 \003c\261;;\260?.r\262e\321\345r?E\243\332\n\007\246\240?\001\263A\304\336S\240\277\200\235y\2166\363\274?jX)\274\377\200\261?\312\036\337\206t\010\212\277zgU\016\025\366q\277,U\345\265\361\372\232?\307n\342\301\236 \313\277\253\373;\265\374}s\2771\214\345\323\366\032\215\277\227\234\r|\013G\246\277zJ\250\034\311\305w\277>\304P\003A\263y?T\211>\n\016V\241\277A\354\233\274\306\033\200?\227\365Z1Kj\256?e}\253|\233\263\237\277bc\350\315\317\206\214?9\262-\003`\017\261\277\342\035\304el*\235?\272\357\266\211\3164\243?\271\"!lf-\244?\005f\032z\346\304\213?\363\321\321\300\364\367\252\277\220\277\206\332\260Z\227\277j\252\013\362H\344\232?\374<\242\341b\240\204?n\221.H\272u\277?\226\203\342\345\215Q\261?\202\225~+3\273\242?\364\r\224\237\242?\263?\350\373\207\212\220I\203?_\007\014\316\337\032\251\277\336N2\313\nP\266?\010\272K\210\021\013\260?\366$f\237`O\244?\354\245\036Y_\372\247?\310\321i\010y*\262?\277\222C/6H\202?!\023\343\304\354\232b?\246\3314\004\177\260\263?_(MO\263\342r?3Pu\253\353.X?\3665\321d}\342\253?\370\226\270R\215\037\221?\317^\230\r\252X\244\277\227\007>\2268\270\264?\340\r\201r]\316w\277)\007\312\265\301\357\244\277\351\301\0027\334K\246?\t\021E\303\202\252\264\277\nOA\232\304\014\241?\0000\026Z\336\324\221\277\362\321\016\nR\376\255?\004\377\375\326;S\251?\311&\"\306\001@q?\"\013\376\316N2\241\277\266\226\210\237\253\301\265?\311\352)\014\321b\276?\2179\361\"+\330\231\277\366\222z\366\271\215\242?\r\022j\237`\330\262?\\\r\341\260e0\232?X]V \324\217\247?\372\030,\315SM\241\277\203\327\341\364\031\271\265?\20231\037\005I\245\277\3106\025s\214\016\207?\324\006jR\2769\231?\263\307\341j)=\221\277\262_\342\314A\030\257\277\334\225\024q\260v\277?\010\346\243\207X\220\262\277\013\036\253\375lu\235\277\361\2106\301\035\317\240?\352\351\003s\000\327\242\277\272{\036J\330+\230?\330\331\215\002\250\376\233\277\370\325\345738q\277N[\266\326\200\222x?[X>|i[\274?[\352G\260\275\332\225?#`\2025\201i\243?\376\\\342\376\372\225\230?)\371\350\230\201\302\214?\037\000\271\306y2k?\301\301\242.h\227\250\277\275\375\204\273=\031\206?\333\267`e\245Q\\?\2358\367>\265\304p\277\315\005\300\231\270o\301\277\255\224\337\353\006\321\252\277\265\307\022Z\375|\260?\003\030g\227\310W\221?\344\361s~\332^{\277sx\311\023\372\200\245?\301\231k\335\026\273C\277I\353\221\335\301Z\235\277\017\301!\210P\347\252?\212\270\2020\261\271\245?\302\243\001\351\202\n\214?R\222\267\272\324M\236?-\234\313\302\016.\254?\221s\363m\205\260\\?xER\355\177\326\221?2\316V\000=\203\233?6\365\005\206\217?\243\277\277\264\337WSq\204\277;\323 \201\347\341\212?\237\221\212\325\"\306\254\277\206v\020\206\204\247\233\277\342\377\205\004&\324\312\277\306oc\270\227I\260?\374\rf\264K\233\212\277=X\244\357%\032w?\304\020\237\264\023\002\245?\312U\206\273N\321\227?\004;\234\272\344>\306\277\t\267\343\1771t\245?c\031\202\250\213Yj\277\303\377@\312\014\261\326\277n\305z\035OU\226\277k\024\202\310\324=\314\277\257\223w-:\361\311?\277\310\327\362\246\277\265\277\241;\364\37321\307\277\240\253\265\312Sv\251\277V\317\\.g\342\256?\373\277\374\345\235\353\217? \3408\272\243\244\222?\353c\006\304|r\272\277\200;\235\334\364\325\263\277\254\362\022\272q \257?#\034;\243\205\222\240?m\377{\2508`\263?\231>\325\212!\271\244?{yu)\272;\303\277\257b\313\204\301\357\302?\366\371\03370x\242\277\353,Xl\305\344\226?f\370\370\315\375@\261\277\037\236|<\264=\255\277\031\321\374a\265\254\250?\251\025e\256\353\354\301?\004}OW\253r\264\277\335\353\300\2261\312\254?\362,o\362\367;\227?\325k|\302\373\363\257\277\252\'\306Vfv\241?\304G\031\223v\t\210\277\203\245r\263\320\267\260\277k.\223\323%=\256\277\311\237?\377\242\303\265?\320\343\357\211#L\230\277\004\246\300\301\275\021\256?\373\263\322_\252-9?\352\033o\233\274\013\222\277n$\027\344\347z\220?\356\257{\n\236\257\244\277\332\202\240v\276\346\227\277\026\177~cW:\233?\332]\336\3345\216\231?4\261\344\325\341\333\207?\357\rj\363\255Y\252?\313\212\312\360\243\255\251?\271,\274g\022\007\263?e\256\302\2516B\232?\032\205v\336\360\231\261?\036\"\307\225\302\024\234\277\257P\245;\375\270\304\277\215\354<\036Eu\241?\037\236\036\003\226\222\305\277+,\275ER4\206?\346\177\350\2602\276\240?|\343\204\311\247\317\263\277\\,\327\232\274\335\220?o\260D\027\006\'\272\277\331\250y\337b;\304\277\201\245\037\356\376nX\277\2473\020,\214e\302\277\306\371I1Ax\271\277\274\320\272\304YN\245\277IeMQ|\370\304\277\203\240L\225\r\301\253?\366\313\360e\245|\242\277\363\341OB\200\354\275?\252\305~b\023\257\320\277\376\205\316KBI\317\277\026:V\364\266\367\263\277\261\277\033/\352.\232\277&\257\325l\023\221\254?\220\302\213u\352=\300\277F\320\340\215\"\272\264\277pO\311\320\2638Y\277\325\003\\\310IbQ?SAK\2327\215\267?K\210>\371v\221\252\277\361\351\355+\346\235e?GE\'\223h\315\301\277.\271u\215\nPe\277\025I?&\024\253\253?j!\351\001\035H\273\277\232\022\223\022\247\374\254?\323K\374\316H\275\235?\271\310\202\213Y\212\241?w\375\232\310a\007\222?\304\257\232:WI\221?\232\272\207\025,\'\247?\177\250(\276\023\233\247?F\020\023?X\317\302\277=\323io51\255?\215H\n\256\335E\276\277\007\t9\340v\027\255\277\225\376a\025\310\273\260?D\276\361\366\316\237\267\277\000\330\362@\210\'\211?\226\306\376\337!I\253\277!\003\334\000]\024\270\277\211C\363\252]\364\322?\353\216\247\362\242\354\271\277\252\360\002\246\353}\256\277f\273\031F\255\257h\277\314\351\233\027C\254\266\277t\270`0\'}\222?p\214k\010\250)l?\332\210\275\224\273W\302\277V]\347\304\233F\217\2776f\273}\354\262\260\277s\243\335+\200\224\223?\370\322\366j&\202\227?(V\014\363C%\246??\324\301\3732\016\260?F\253\004\325\263\017\257?\340\2731\355\233\361\247\277\222\214E}\233)\231?\034\354\263\251|\032\252?\234-\274\340\321\206n\277\220\327\236\314=\341\233\277\037\"\276\216\333\231\260\277Z\367v\324\205M\260\277\226a\225\265\2535\220?\237\331(\204o\301?\347\255\376\'Kl\271?{ \323]-L\227?\251\376~rCr\251\277\003\032c_\027\225\232\2775\232d\232\233\225\224\277/e\337H\315E\300?m#\324\204\367\202\243\277\034c\031\256)(\250\277\317\261}\035|\361\260?\234o\305}\177\202\270?\233\330&0\240N\245\277\323\330`\316eo\244?\024d\267\274J\366\253\277l\220\305>+\335\251\277\213\364\"\203r`\233\277\366\306\034a\2270\214\277~IsPC\206\240?Y\317\343\006\221D\256\2771\267L\t\223\361\235\277\265M\343,\005\317\322\277\351^\2269}\213\244?\252\000\350\025\237\221\220?\003_\0012\325\253\233?\004\352\337O$F\225?\354\313\035]m\r\252\277\367K\\\324P\234\203\277\035\315l\372\245\330\263?\001h\273\352w\266\241?\313.\206^\307\214\246\277\003\246H\314\033m\247?\243\202\353+O\251a\277\024\312\247\312\263\251\257?\317}\023RB\n\207?@;\207\'\331o\247\277T\022\t\006\356\212\253?\266\223cg\331a\253?\267V\325\0055c\276?\1776\307\230\001F\261?}\260\024j\357\252\245?\341RE\236]\213\307\277\247\374\233\225=\306\261\277\2545,\263l\243\225\277t/1\260\035\002\260\2770\314|\216\320\352|?6\206{\257\020?\221\277?\2201\250\377\243\276?y\371\023|FR\207?\2536\323\204\315\230n\277d7\363\211\326\005\231\277?\341i$\210\231\225\277\026\204g\t\200\227\300\277\352\227D{\030\307j?\306\352p\230\365.\231?=M\251\036tY\224\2777\306$\342\302\014|\277\232-\2117\257\200m\277\2567a$\310B\252?\3036x\377\004<\265?Iyh\3646!\262\277>kk\306\246S\320\277\226ah\216=:\300?2\367\270\262\310\357\220\277\250\\P\236\027\272\273\277o\031\022\353\271\003\231?*\303tg)l\262\2773Q\275h%\364\270?\017\252>\2439D\236?\252\2618\244\2231\233\277p8\356\034\023\235\213?\252\354\013\016{,\216\277\344\322?\217\204~\246\277M;1\254\304\237\246?\341y\036u\232\027\207?\rS\351\237\017\210\244?wJ\306nHi\263\27730\245\336\275\340\243\277\277\343r\317\022\214\274?\361\254gU\330\010\207?\004\240\004\\\344\026\222\277H\373\2300\241Zu?\344\270\010\016+\013\271?e\252\207-\217\210\243\277g*\372\023\"\304\244?o\342\034\245\345\016\264?+f-\345\344\257\246?\221\325\231>,\021\245\277m\220\302\2244,\243\277.\321S2\025\267\277?\002c#k\021\207\207\277\006\343\303CO[\264?\230\370\320!\330t\261?:\353\345S\350\255\200?fo\260 \247\t\251?\243\273\336\266\262\021\204?\365\032\270\252,\231\263\277\377\024%\227,\030\243\277\021\264\344\214\251\345\212\277n\000\277k\320\255\177\277\003\305\335\027\366\020\266?\nb\237G\014\271\251?>x\"\023\244L\261\2779\'\374w\242(\255?\300g\354^\231\221\240\277\226\271\024\247&\241\266?r&b\337\022\005\274\277_\377\305\036\330\347\260\277Urj]\213\305\255?\345:\357$\214y\231?\030\361\374:\206F\301\277\2104\017\247Z\223\262?\026`\260J\367E\177?\232-\375\350\262w\224?\035\241\311\313\340\300\264?\024\314\317,\237\243\241?c\277\242\017.q\263?pf\215az\027\255?M\242\026i(O\263??\212\037T\014\243\241?\337\337.a\277\257r?\376\271k\365\207\272\277\277\263\306\016\035\236n\245?\264\265\241\253\001P\246?\247\"\'\211\327\207\232\277\324\037K\340\274\337\305?\025Y\216\r\220\206\313\277\215\241Q]\217\235\240\277\"@\214AM\345\230?\264\327\177r\270O\274?\265\336}\371C\333\262\277\272\020Z\\#U\216\277\224`o\367\327\005\201\277\021\2712\376\357\364\245\277\322\215k^N\251\243\277Y{\265q\217\010s?\373\363G\316\275;\260?(`\213\264\351\230\252\2772\366\377^k\363_\277\201d\001\361\257t\210?\227\203\034A&\364\240?Kc\310\261\361@\270\277R\302?223{\277\251W\026\004\226z\241\277\253\\@\266uD\304\277iF\233LT\344\225\277\200\007\363\262\357i\220?\373I\243a\255\024a\277\'\253\'@\301D\260?\343\367x\236\245\310\230?\246&\310xMj\260\277n\320+f>\354\262\277j\'\331\235W\023\242?\026@\235\242\210\246\246\277k\303\303Q\017\002\216?A\267Q\033\376\365\252\277\225K\300MMX\272\277i\256\010\023\030\035\260?\006\376(q\031\264\211\277\333k\302\275\240E\242\277\360r\031\346\007}\211\277L\201\207\377F\236}\277\241~)#\300\274\261\277x\221\014\2724Y\250\2772\030>\330R\305\230\277\323F\037\320UX\300?\307\257\312C3\317\243?\220\313?0\332|\264?\211\334\tP\374\013\247\277}\035w\300?D\240?\037\250\267\3645\223\262?\233L\247\270\374\t\270?!\336!\3524\251~\277\022\236 m\'\033\266\277\245b\023\210<\330\300?\205y\302\017\226G\311?\243\302H\322_8\304?<\221\213D\311z\257\277\321Pc\236?\036\265?\366wR_\265\217\264?\t_r1\344n\263\277\212\240\266X\230\233\240?\361\006\2548\r^v?b\354\306\177\216@\241\277\034Q\010\025\270;\250\277_}\007\366\327\264?\353%\234O\330\313\256?\017\367^\365\363\276\260\277\026\376-\240H\355\263\277\344\352\346,\341\025\261?C\362\344W\372>\241\277(\227\343\013U\361\271?\027\2361)\211M\274?x\"\240P\352\350\300?\305\271\216\341\252Z\300\277\327\312\332\035\227S\257?\207\377\037(\340\245\272?\321\303bI\203\255\265?\243>\253\032+\003\305?\314y\234\364|:\255\277\031\354\252\003p\271\247?\277\335\340\252\243\220>\277z\344\305\377H\355\303?}uo\211t\250\276?\315\222\263\014\357A\303?\263\027\234\261\365\'\262?\rq\303\347\303\272\232\277\360\014]\326\261\277\264\232\366\225~v\254?-\033\0348L\271\303\277\"\310u\212\257\246\300?\367H\212\260B[\251?e\376LBL/\303?\205\351\037\303\364c\251\277\342\203x\361\231\351k\277\304xF~ \302\247?\231\342\033Ra\206\305?\355\016PeX\210\223?\253 f\036D\245\305?\331\\\277\204g\235\240\277\210\375G\013\341\362\275?;$w\351\273\313\251\277\304m\344L\013\225\264\277A\\\020\251#J\206?<\td\233\254.\260?~f\014([K\250\277\327;d\336\340 \252\277~\000\345\002\262h\233\277\203\311V\004Ys\227?D\215f\r\303N\265?\t=\266\n\322f\222\277\300\3504\250\276t\253?\214`\362\215.\225\237\277\331!i\033\215D\242?\016\207\220e5V\263\277\000\022\364A\351\330\254\277c\276\2569<~\250\277\3055\355U\256\036\266?\2512,\200\224\002\251\2770\277{\223\346G\214\277\022y\2036\334\260\224?4\221n\216;\246\240\277:P\326\2762>\245?\344\377\311\310\203\250\303?\346\2004eg\225\207\277\341\202\227h3\256\177\277\367\215.I\0034t?\240\010Y\035?\030\220\277t?.h\206&\305?\246& \311\337\033\266?y*\204x\277\027\236\2773\027\314\336\333\243\243\277\255Ba\200u\377\240?\326\266IW\030\313\244\2775\311\363T\255\236\220\277%9\302\240\243\225\231\277\257\203\3514*\225m\277A\376\237\244\tE\262\277\370SF\324a\320\204?\t(\326\205B\266\263\277r\304\241\0209\216\247\277Xp)\222\365T\314?!\3204U\021\262\250\277\334\261(\177\363\264\272?\271i\212\n{\032\274\277\302\360>\014\007\303\262\277<\346\253\376\334\347n?#8\2511+\231\264\277\3201\311|\272\003\223\277\267\035\207n\022\226\200\277_9`\356+\225\252\277\237B\252\200\025\321\225\277\014]>\204\334#\237?\020\2075\242O\265\252?l$\224hCP\273\277C5A\376\206\027\220?\312\r!\200d\036\206?\311\016\270p\372g\303?\346\255\3519\342)\260?\030B\344\250\017\003\310?IT\322p\250T\227?\032;\361T\367*\256?\210\340\315of\256\262\277\245\251mi\356\350\260?\034.\306+\"G\243\277\3346\336\276\005\014G?y\301Q\313\346\272\233?\331\233\364Y\360\376\272\277u2E\266\205g\251\277)\250>\224\020S\262?9\263\r\356\032\010\274\277\002\250&\342\250\273\241?\350%\0204\266x\263?\204\235\216\"?\367\250\277W6\201C\305\306\252?\037\002\234\254\356\277\261\277\340\274G\177Z=\210?\027\344\014\3140Z\252\277\361$<\345\350J\243\277\224\332@\007\252\222\215\2770`\"\332[\200\252\277fM|,\275J\263\277PT\357s\321\273\255\277P\007\242\344\327e\263\277I\336z\311\202\270\301\277\0259g\201\270\351\241\277\232\321\375\\Q\321\206?\003.\031\241\004\212\233\277\376\251\250\016Y\220f?\267j\230\263\260\032j?\361\326y\036W\254\246\277?\247\335\203er\247\277\214\241i#\002}\220\277%\342\343X\270\256\234\277\003\370\325\215g\314\226\277\272+\200\351\016Z\256?PU\3109\022Z\271\277\233\322 \010\266\327\252?\364U\252Un\365}?\276/\374\375o\036\227\277vM^\256!Z\232?`\3173\005\322\274\263\277E\305}0\022\264\260\277\215VK\262\325\310\261?\303\347\336\271\261u\260\277\334\207\030\263Hp\252\277H\253:GL\256g\277\315V\017\337d\340\221?\333W\303\230\004`\270?\347#\350\372{\002U?\353I`\333\r\343\231?1[\3223^(\226?G\003ew\220\350\211?&\376\344\303\365\263\243?\304I\247H\204;\233\277\261\366\t\007\177\330\214\277\252^\210\204\201\333\273\2774\250\255cwe\242?\250\216\032\236\242\372x?\344\203(\217\272\207\232\277\353K\037t\266\267\\?\232^V9h\343A?\351\034\245M\277le?\354\350\213i\205\322\257?\365~\026\376\000\340\256?\007\\\303\226\251\337\255\277+\212\2155\214y\273?\366\2007,xP\262\277\032\211\376\321c\230\203?Y\270v\240+~p?x(\357\317\314\333\214?\230\033\221\214\362.\244?\2309\364m\363\242\216\277t\357\317\005\350\031\242?\030\202l\007\312\264\207\277P\377\033T\000n}?\346\251)\313\201\'\223?\215\310\r\377\341\216p?uM\356\\H\377\236?\030\333\270\367\037[\242?\"\2758\000\274\336\235?\243\217\352R\303\210\244?.\201\210\214\312i\226\277c\223\264\2206\337\263?+7\3344\323\330\313?\2346\214\0238U\231?\336wBI\275\231\276?N\036\243\001\236\311\241?\337>\332|.\321\260?e\"\264V\250\017\247?\001\224\305\304\314+\276?4\326[\023O\351\261?\305\014\335\261\007%=\277\324b\216-V\023\253\277K\313\006-\202\027\244?h\347p\345R\245\246?\374\304\036\327T0\260\277\216\253\3030N\006\244?\031^\327\244\034C\237\277\252X\353B)1\247\277\025\254\3671zp\256?\354\204](\321\034\231\277\264\305\"\372H\355\237\277_\336Xl\230\005\267?\352\312\375\266\033o\257?\330pl/\326\377\266?\024\355\253;\027\031\200\277\307~\034p2m\254\277\331\220\357\365\301ok\277$Q\370\034\305`w?\010\303\000\177\227\355\305?\233#\241\353l;\301?\225f*43\351\241\2772\003\r\303~u\202\277WXA\252y\250\276?_w\354\003\020\361\270?\311\343^\336\337\332\251?\202\374x\245T{\300\277\361)_\277&\305\277\277P\000\3360\247\001\245\277u\313\033\000\037\203[?\022w\014\020.{\256\277]\352\274\256v7\230\277Z9\0141\352j\215\277\222\250\327z\337\260\242\277\246$\341=\230K\245?{\027\370~\204&\243\277\345\341\350\355\036\242\243\277\000\253V\333\227o\262?z\376\204\306\222w\270\277\375\036\237\346[\245\274?\377\252v]\343t\242\277\264\325\246he\245\250?/\033\213\2705\221\263\277sY\260\000\340\355\247\277u\354\241\353\202\023\261\277\310\010%\034E\250\247\277\3056E|\333/\277\277TA\016t\206\367\244\277\201\344\300\270\370o\220?\366\334L\023\366`\232?WE\314\022|\210\215?\206\342,\267\316:\225\277\232\270\332v\342G\250\277x[\306\2601J\265?\213BM\225\037\250\213\277\035\007\304\\\256c\236?\016\270Ok\351\356\302?\255i\030\265\001Mx\277\362\005\212\2662\222\254\277\333\330\226\320p_\243?v\021\235&\320\323\201\277#\304+\273\353&\245\277\330\363~\227\332\352\245?\207\311\002`\274\017\253?\024\367hv[\363\255?\211\206\3539\275i\274?\256\330u\031b\r\232\277\370\2030\227\005\037\252\277<^-\216\'\002\200\277\234 \221\203@\262\267?\177\306\376\220i\275\272\277hC\350\362C,\250\277\225\371\214\316\237z\261?\322/\177\310n\206\251?.\220\352p\305\317\305?\321u\304@\372_\237?>R\007r\306M\250\2771\262\342\005\035\016\262?P5\226\003c\313\242?\267zM\361\r\262\263?\260\354\364\377\007L\220?\367/>\211\237N\233\277\246lh\236\227}\302?\351\324\240\23173\263?\205\034\037w\232\025\250?\311\020\253\302\"\326\250?\370\031k\373\326@\245\277\000\257\207\236r-\261\277x<\366&\335y\241?\003Dr:\221\302\260?\010\017R\032Z\243\263?\264[\\\337bK\244?BV\004^lf\226\277\312\3463\324\2533\253?B\255\000\330\270\336\224?\006\222\207?6\215\206\277\344M\344\3245\332\254?\355\300\007\340W\227\230?\336\030D\223|\350\245?\337R\347\206B\312\240\277\021k(\326Jy\243\277\373\016\006\327\003Bp\277\312s[]\350\322\245\277\221\327\376\262\373U\243\277h8$\212\232\221\203\277\336\351|M$i\245?\030$\372\261\274b\261\277\350\262\2571I\032\226?Fn\3678\236\324\241\277f\210\220D\025:\201\277\'\230\325\212\342\340\274\277S\305\222\263\324m\266\277&\256=^B\300\273?U\376\320\262\003C\271\277Nu\272G_\357\262?\255t\037;\244\247\220?*\214\366\277\"\023\245\277\256\337\227\240\340c\267?\r\007\343\022\006$\272?\272T\306\037\225\264\273?-z\242\356H\374\264?\006\237\324+\006\206\270\277\3704\251hI\316\240?\205\373S\001^\225\244?\034a\365\327\036\227\273?\3528\254&\250\345\256?\315\255\307\2311Z\232\277Q;v\266\310\274\257?\002\263wm\016\233\266?\337\360\227\317\021\266\266?\021\217\331F\034]\253?5}\250^\332\317\223?\223\231\334H\340l\203?\261\246m\204\0223\221\277\213,\251nh\002\255\2771\261\235\255\021\027\232?Q\334\271s\354r\241\277I\336ILp\236\244\277B\235\344\334u9\236\277\217\242\327+\275\261\251?\372\337\014\244\253\010\212\277\342\277\340>\347\306\263?*\344\nL@\317\211\277\r\236[`\270\377\216\277y\265!l)V\241?[z\224\026\277\240\233\277\373?\347zG\031\272?\217K\376\245\274\322k?\304\262\276\347*B\246?\371\036U\240\366.\247\277[D\224+62\201\277l\204\331\'\270\211\263?\033f\345$\211\321\210?\263\325m\260g\'\237?#\n;.\363\014\240\277\033\246\266\347\006>\244?\241\025\035\306\322\001\203\277\003\330\371\030\002>\231?#\223Pm\370*\260\277 N$\257\236\226\216?$\336W\257\274P\230\277P\365H3f\014\240\277\222:\240^\335$\226\277@\027d\t\262\321\220?\'\301\313\241f\254\234\277C\027\243\217U\234\245\277\262\352S`\036[\206\277\224_\023\321s\006\232\277\360\206\024\326B@\271?\355\037\317\216\3049\251\277\334\370\371i\262\306s?}\373\024V^\007\221\277\005\031\314\3711\334\272?\276\330[\373\365\337\222?c\375\367Z\237\376\206\277Z\"\241SS\256\231?~\305\233t\027e\226?\220\212\350\323K\277\253?\361\362\275O\371\301\272\277\262\001\007Oq\362~?1)q\n\253w\250?t\255\032 \330\371\222\277\207u\230\211h\260\275\277\312\271\212\323\335\027y?\375>\261\021\025\257\222\277D\226\377\277:4\230?l\375R\3030\320\220\277m\341$4dE\266?}\301\354G\\\340\210\277\265\235\026\342\211`\264?\014\212\304\373u\243\225\277\251;\367\257\201\004\251?G=\3240\022\001\275?g\0364\215m\\|?\301d\204\242\201;\222\277\267\351\231B\232@\302?\227GL~\307=\252?\341G18\325r\262?\331\277&\220\212\324\201?RZ\346\263{\317\243\277\261&\334\263\371\331\256?\304\257\361\303Q%\221\277N2\267p\352\274\204?`\022>\201\302<\205\277\252\037\0060E\320\221?*\346$&\252\332\213\277Yu\003\036\354r\221\277\224&I\026?\340~?5\232\345\303\302\214\262?u\001\264\210\252k\250?q\370>\025\214y\262\277\300\334\034m\r\306\240?\222\001\002e\200U\243?i\330f\323\354\220\254?\"\3116\2751\016\224?\234p\355\370d\010\275?ie\265C\177\225\226?\316\3401\217\340\370\261?\242\025\257\013\273j\202?n\347?\273\025\316\251\277\241\251\350P\022\224\202?\370TE7\264\231\245?\277W\315\334\306m\234?\212\244F\270\244C\240?5\242D\226\224\270\236?4?H*/\332\271\277\244q\004\237\222Q\264?Y({\253\367jr?\203\031\240\277\255.\254?\352fzE\tl\244\277Y\311w\010\325\335\242?&\0374X\334\307\240?\0208\226\2216Pj\277O\023\304D\207=q\277a2;!bvS\277=\221\346\374D\250\216\277q\352\246V\023\231\233?=Q\371\372q\321\264?\322\215\177+\206\222\242?/\263ND\310O\250?\213\037T1n\244\242\277\271\013N\322_(\271?\326ST3\201\214\264?\271\251hj\306h|?\241\230\205 x\320\233\277\366\311!-\226\227\252?\031 \365f\256\333y?\365\264E\307_[\266?S\336\307\337\231\361\245?\351\032\001q\317\204\223\277]\335\232g\001M\200\277g\223\346\032\273\235\205?\017}1\227n8\267\277\366\025I\247\\y\252\277,b\230&\036L\267\277\376ZO\332M.\305\277\337\020\216v\206,\217\277\347r{\351\346*\220\277\213lR\224s\361\210?f\210\257\241\206\270\246?\354\240\034\320\262\322\203?5\206\036\021\3077\242\277\322\361\t\214-)\240\277J\335\350*\014z\232?{\271\362) \217\204\277\300\226\366\020<\301\252\277C:\337\300\033,\246?\036\216-\272\031\340\225?\347\335\372\3058\371\264?M,2\343\357\266\277T\003\000\227(\235\246?\236\262\nA,Tj\277V\346Oj\372\223\302?\317\2671~\021\330t?b.in\244[\222?x\255}\003\030{r?\024\273\033\304\265\273z?Cz\300D\377=b\277\017\317\261\022\376\232\275\277\253F\343\031\221\323\261?\234\331N\247\026\\v?lA\227-}\347\253\277e\027\245\315\021\264r\2775\273\3063g\352\241\277J\274:S\240\327\252\277\377\234\336\207\'>\245?\305\345\005\261\'\315\260??\327\034\n^\307\223\277)\320\204\303\326o\235?\252\260\330\002q\352\275?\356\334Z\360\320&\260\277\231\253\324\373\252/\250\277\233\251\235\032=\340\271?\204B\216\344\373Xw\277\003\024H\275\027\033\232\277\344\220\216\315\313\321\213\277\276N\321\230\302\022\243\277\007\0107\210\225\226\241\277\306\256\250$\016\263\233\277e\267Z\231\2054\273?\020/k#1\022\207?\024\031\335\231\345Ne\277{j\374\351]<\235?\324\341\243C-\264\243?\322o5\251\270]\261\277\023-A\026b\240\226\277,v\325\013\227K\267?\250;\017\031\333\314\262\277V\0133\303\037g\203\277,\256H\262\303M\272?\336-\300\301g\377x\277\362-\222^\224>\323?\027K\207\2601-\261\277fl:\307\000\203\253\277+\030,\255\302\231\272?o\300\303>g\320\262?\336La\222\025!w\277(\204$?\n\342\303?m\336\263B\274\343\244\277\3665\2471\270i\276?\241k\340\014H\217\331?\r.\333\344\340\020\260?y:\216\350\372\264\322?\232X\200<\212g\275\2778\277uh\307?\256?>k\265\003\345>`?m\2716\317\227\333\240?\301\320\225\260\2600\220\277\242\326\366\013[\200\235?\371\254V\242\r\304\264\277\226\231\306\262A\247\202\277]n\340\376\265\003\230?zY\350\264\032z\271\277\331>\350 \013\337a?\316\265\3404\220n\211\277i\333\026\234\204c\260\277\312\354>\027\036\027\313?gY\374\303\354o\256\277\202\223T{\324\201d?(\215\372+\3030\261?\032\351\220z\n\031\234\277\220\022e\374\035\315\244\277\016\026\354\235x\306\260\277;\363\246\237w[\244\277\034\336\307\365=]\265?<\271\246\032\330\226\250?\303F5\"\207:\230?\2766\007\333\033\035\273?\336\n\302\177\315\206\262\277\333F\205\316\272\217\251\277\246G\260\026\267\230\275?\005\266\316\302\307\245\207\277\347\230\350\314\005f\273?O^Bl\376O\234?\324\200\374\241i}\255\277\247\277\223,\\S\273\277C\256fA\031l\267\277?\024\026\0304\315\201\277\220\226\255\344\351^\206\277\215x\332hSI\232\277\274\242c\345\341\253\257\277\003\256D\375i\226\260\277J_S:z\221\247\277Z\223\246\225<\275\250?\312\022\004\370\317\342\274\277\004;`\001\'^n\277\356Y\031\225W\210t\277w#\336\240\022\025\223\277\326e\217\377\335\376\263\2774\020\340Hk}\304?C\2230\340\274\276\216?\243\001F\010Oq\260?B\362\226\354\301\272\246\277b\245\213\273\202\337\240\277\223\350J\240\003\317\263?\212\301>\274\241\200\261?]\020{\032\204|\306?\313ij\2118\302\300?7#H(\347\250\230\277\216dw-\240\204\205?\345\272/b>\030\304?\201\352\177FP\225\263?\263\314\231\027\r\342\265?\312\233\343\003B`\363\276\220z\253\245\240\336\262?\3115\"\305\352\217\264?\345\265v\030\016\014\300?X\336\260\010d\246\322?z\025\232E\343V\246?\322\030)\311\226e\265\277\320]\360\265\302#\267?\320B\032RW%\257?L\350\371\036\250e\271\277\267\"9Uy!\236?~$@`\027\003\221?\014\340\361\255CN\274\277t\321\246\311\332\376\247\277\036^\004\222\306\312\201?\346\261\236\2731\010\257?\177\372\025)v&\203\277 \205k!\350\217\214?\376\022k\244\300\\\233\277fP\177\317W^\260\277\271\335\253\022\2300\212\277\244u8\237\246\236\254\277\260\000=\017\3637\214?3\341\031w\373=\231\277b\325P*\302\371\262?\222\221\244\304\310\200\241\277Q\210\330\216\367w\277?\266ST\256\235\252\241\277\204\361m\014\236\370\271?]Gb\370\265\200\260\277\312h\272\\\223\245\210?\213\027\007\t]\252\311?\260I\030z\345>\275?Q\310\265\350\201\347\262?\2324V\325W\022\242?\007w\246,Y\225\306\277\2474\370\202\005\316\266?\013\2501\003{\303\241\277#\207\264m\340\016\266?\340\311\355\207FI\266?\351\377\271\356\362\246\241\277\302\365#\310\263\234\260?WFT\r0g\306??\315\325\010\020\257\302?\260\217\365\364\020\233\257?\224\314V=\217\034\216\277\036P\016\220lw\232?\030*\307\203\024\006\272\277\244\226\001\355\326\321v\277\004@&t\333T\246\277\312X:\237AC\234\277v\340\370Hq\306\221\277=\250\347p\361\033M?\212(\326UX\200\313?D\327\0206\352\024\236?;1\034\375\266q\200?\2731o\304\237\304\240?\335\237\037\013\376F\270?\305\253\251\245j\003\247?\345\241\263\340\271\320\266\277\257\020\215\231\346\312\275\277\336\234jE\247\304\226?\251\345U\360\346\351\264?-\344\035\247\261\325\251?5\3143E\220\301\264?q\242\320\217_\244\302\277\014f2\301\370\t\255\277\261\341\214\037!\236\276?W\020\034\025\306\232\216\277\252\333\336\353\025\224\307?\244\017\321\314k\332\263?\3242\356\342\3138\272\277\006y\247\266\311\036p?\210?\277M\321\006\251\277B\025\n\274S\242\217?\330\324\373\035U\n\207\277\356=\363r\372$\201?\245\270\263ubt\252\277X\303\212\371s\360\246\277\323\366Vd\300\375\213\277\001\275\023\242\362\022\233\2773\266\264t#D\227\277\221;\334g\256\252\247\277/\256IIJ\330\250?-\250FM|\303\266?\271\216\270\346\366\002\265\277\236K4\002\323P\234\277\021\035\\\313\237q\266?muC(\205\255\261\277\255\375y\022\032I\305?Jp\373^\030\346\262\277h\360\265\250\326\022\207\277\021\3763.Xx\301\277\305>\367L\274\004\242\277\272\270\212o\223\261\277l0/v\253`\236\277\367\026v\177\362\273\232\277\206\323\250\037\277\216\243?)\363\243\265B;\302\277\266\\D\026\205\302\236?a\200\216\377I\261\255\277\024\255|y\234\227\222\277)>\362\\\004_\235\277F~+r\370\260y?5\221un\323\227\217\277\007\327\352\374R}\300\277\252\340\256\366#\035\263?G\'\026\317\252\364\316\277\230\264\316\323 \251]?\352[\305\017C\"\264?h\277H\370\236\300\231?i\220\265\317B\363\214?!h\210d\\o\242\277qt\230sM\372U\277&\021\031\006{\233\260\277;\200\027\006ub\203\277e\216\235\251\245\347\265?\0216\343\233?Sw\2779X\267\374\314,\232?\226E\227\344\265\303\274?\272\275u\335t\231b?\257\262C\277\0148\242?*\312\345\315\222%\275?\365\277\177]\304\203\254\277\207\254\221\255\000\333\243\277\032\250v.\315\253\262?\300\377,\235w\361\246?&\376\375\022q\354\321?\303v`w\030\367\241\277P\356\357\263M\307\223?\303U\274\234\003\330\220?e\307\275\006\213$\233?\306]p~\035\372~\277\276\257\254\323\213\224\255\277\003\361\353\017J\303\252\277*\326x\023#F\233\277\272\372}wO\240\262?\034\334\304\020\354=\201?\371\273\023\371\370\336e\277\374Vn\265\027j\255\277\202\342\372\226N\334\263\277\327\024\301_\010-\266\277\266\010\213_\224\363\321?Y\214T\3045\311\241\277\014\001w*s$\230?\215\204\352\361s\214\244?{\210-\316\366*\240\277\032\374\227\344=a\273\277\370\3427\257\312{\257\277\255\037\'\220\222\317\243\277K\"\305r\233\232\206\277\303J\215\207i\275\240\277J4\037\253\266\267\207?7\243%\037\005:3\277G\220d\256\201\234\251\277s2x\217\021\227\260\277*[#|7*\220\277\220\230\001j\202\310\230?\031\013\004c\306\201\245\277:\254\302\002\351\344\217?-U=s\373\024}\277k\374\326g>z\250?\255\2421\000\271.\312?\025\352\'\306\320\210\240?\345s\214\240\375\021\261?l\0106\210\320\001\250\277\330#\271\230\201\024\243\277\241\326\372@\371\356p?\244\3738hxwe\277\2519 \301\372{h?\022\300\325\256\317\312\260\277q\243q@\264N\240?\231St\3023\315s\277\206<2\306\244\227\273?\360X0\234\247\n@\277i~\334B\2249\212\277\344\255k\307>\036\260\277\220Q\311\234\214\207\266\277\373^\322jZ\001\300\277\337\3013v\270\210\254\277\270\364\375\350E`\274\277\022C\035\337\310\013\222\277\210\374\003\377\007\201\322?]\3343\273\005\217\274\277#\354*\350~,\221\277\311\212\232\344\315>\242?\024\274[G2\003\234\277A\336\014\353\023\224\253?\262\266d\3655\033\244\277\016\225U[\266\364\223?P\037\375\330\255]\215?`\273\224\022T\037\225?E\224\215\374=\000\237\277\372H3\006h\322\206?\204_\356\225Je\251\277D\303\020\002j\371\206?\036qH\2667\002\270\277fJV\020D\023\301?\206\305\347\315D\377\206\277\033\334s\t\343q\276\277^B\010\216\020\235\261\277\224\264\341\037\366\262\262\277aG\2003\302\201\212\277\321\017ng!\'\262\277\226=\200\340\316\027\224\277\312\3728?rYx?\276\035:\006\030\256\255\277\223\332\274+n-\266?}Sf`\265*\213\277\343\030\257\266+\262\254\277\342;\330Wl\237\265\277+:JX4\247\237?\202\007\315%@\264\260\277-r\353\007]\223\254\277\363\252ia\232|\232?\337>\267G\246\274\250\277\343\240\277\"{\356UY^\246?\021\235\355O\252\323\201?I\255)Kz\353\263?\275\253\213\270\321\261\253?\001\177\345a\037D\253\277+\332\322\211\025\223\210\277\356\005\270r\374\226\243\277\331\331\261\tV\272c\277m\221l\316\263\"v\277\1770\273\371\333\234\225\277\3131\031\235\273\373\250\277" + } + } + } +} +node { + name: "final_layer_type_0/matrix/read" + op: "Identity" + input: "final_layer_type_0/matrix" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@final_layer_type_0/matrix" + } + } + } +} +node { + name: "final_layer_type_0/bias" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + dim { + size: 400 + } + } + tensor_content: "\036\242\365#\205\226\305?\030\337\304y;\244\350?\200\232\230[\365\242\370?\271\221\022\375.\244\327?fE0\024\272\213\370\277z\027@Dg\303\362?\214V\010\r>j\370?\034\'Z\272\327\032\340\277\030\216\037\230qP\316\277\323\256\203\312\3248\320\277\243\323\362\004\361\232\276?\346\362\335\221g\331\350\277\022\352p\016p\306\377?\2737K\332\022\201\323?\271\004)\025t\343\306\277!\344\026\366\326\200\341?\254b1\025\2304\340?\255\177\374>\214\201\362\277;\301m<\004q\361?\350,\217\277\332\324\365?E\350\210\343\266%\334?\315\217\366\227\357\005\361?\331A$\321\317w\370\277\316<>\366\237\337\374?\034$\0216.I\360?\005\223\235<\303\034\326?c\202\001\250\203\032\371\277-\000x\307\016O\351?Q\272\216-\220\250\347?\350[X\204LB\276\277\273k\214\276\277\266\314&\242\345\010\253\277\2054\235\223\267\204\320?\033#\036\0267\312\346\277J\247\374\322\222-\253?\375O\363\247\030\\\331?\262\002$R\027@\356\277\034\014F:\370\237\365?\213\337\207\3128\246\374?\177WdZ\2137\363\277D\r7\233s\353\271?M\254n*\031E\365?2\3333!\205\375\366?=\t\000\211\374\020\360\277\335c\026\322\323/\345\277\023\\\316\nE2\326\277E\317\\f\371q\356\277\266\220\334\035<\252\335\277\027J\004\010\301\375\340\277Ox\007;\"d\344\277B\331\341\357i\373\344\277\332M\364\366\234P\354?8E\367k|\304\353?\003\2469\275\026\351\372\277\000=\204/\0271\365\277\356Z\352/\000\315\341\277\230\264\r\036\3338\341?4jw\343\261\252\370\277\217\247\241\321p\251\360?\230\356\256:\262\344\374\277s\357\005\334#P\336\277P=\006\310\"\357\377?m\327\376\212\2504\326\277YY+\261\007\242\371\277NJ\021M\245p\362?\361pU+\363`\264\277\264G\034e\203\365\345\277\037,#\247\225\325\334?\366\205|\241*\222\340\277\327kz\340Lt\324\277\321\023b\321\320h\353\277\026]s\203lD\003\300\335\006^\252\013\231\243\277\031\235\327\216\227\024\334?\204*L\260\016F\350\277\376\202\014\034A\205\322?\257\214a\210H\367\000@\274\345\210R\252u\330?\264\234m\247\021}\335\277\374AT\326H6\351?#\005\033\305\377\331\374?T\227\262;\314\217\317?:\375\177\210\240[\303?\223\343\341z\003^\376?\376!w\374\314\346\346?\245\236K\337\357\305\300?\320(o\355;\237\360\277m\016\273\377\340f\330?\242\016e\240\272\227\356\277oTLx\305\344\340?Pm\217\331h\202\355\277#\325\242\344\321\304\360\277\3324\270\202\233\021\316\277H\262\367\002g\271\360\277\367\323\233\010\002\202\357\277t\311:\215|\020\372\277\3101\005\357-]\315\277J\001\264p\033V\377?\353n\325\314\3442\355?\251f\007\263\373\217\305?\220SK\203\3407\345?\014\361\265\304R5\361?\307\223\265\036\266i\322?\207}\277pc\256\266?|\370x\314\352Z\362\277\227\353u\233\014\223\306\277M)$\214P\310\353\277XE\235\220`\"\343?\372\341S\016\006F\362\277\3617\371\333v\037\314?\314\217\272\274%\006\366?\016\312\352\303\262N\371?\003\326\340\"\363\037\314?\214\240\356\322\332\\\340?\220#T0E\226\377?Yw\202\352\216\203\336?\314\034\302\222\222\227\334?0G\325C\304\221\353?\222\256\325\256T\360\360\277+\246\250k\207;\330\277\324S\013Y\242)\341?\271\275\216?|*\345?\270\306\263W\372\366\313\277O$\335\377\262\t\361\277f\035\026t\001\217\361?k\202\t\310\000\264\320?\200\223f+4\035\355\277!J9\235%\261\320?I\242\337!\021\313\332\277\210\0261\345\366j\252?\024\004\3048Z*\325\277`\252\001lB\362\356\277\2010<*\301\203\332?E\031T\257\217Y\377\277L\314NK\274\340\320?\364\374\0057\221\251\360\277P3\246\254\360\277Q:\342\331(D\367\277\320\313\241\2304\014\345\277\213uY)\260m\377\277\014\350^\260\251\210\372?\212\273\365]\010\213\366\277P\331\372\217\372/\361\277\344\370rP\000\206\364?8\245\225\343\205\337\372?\302D\343\302\271!\004\300\330\225\223\344\306\324\336?\313}\376b\301@\342\277\277\232Il\n\264\327?u\360:F\2440\314?\254]ID\277>\233?" + } + } + } +} +node { + name: "final_layer_type_0/bias/read" + op: "Identity" + input: "final_layer_type_0/bias" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@final_layer_type_0/bias" + } + } + } +} +node { + name: "final_layer_type_0/MatMul" + op: "MatMul" + input: "add_5" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "final_layer_type_0/add" + op: "AddV2" + input: "final_layer_type_0/MatMul" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Shape_6" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_25/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_25/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_25/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_25" + op: "StridedSlice" + input: "Shape_6" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_26/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_26/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_26/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_26" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_15" + op: "Mul" + input: "strided_slice_25" + input: "strided_slice_26" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_17/shape/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 20 + } + } + } +} +node { + name: "Reshape_17/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 20 + } + } + } +} +node { + name: "Reshape_17/shape" + op: "Pack" + input: "mul_15" + input: "Reshape_17/shape/1" + input: "Reshape_17/shape/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_17" + op: "Reshape" + input: "final_layer_type_0/add" + input: "Reshape_17/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "transpose/perm" + op: "Const" + 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\001\000\000\000" + } + } + } +} +node { + name: "transpose" + op: "Transpose" + input: "Reshape_17" + input: "transpose/perm" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "add_6" + op: "AddV2" + input: "Reshape_17" + input: "transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "MatMul" + op: "BatchMatMulV2" + input: "add_6" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_16" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "Shape_7" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_27/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_27/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_27/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_27" + op: "StridedSlice" + input: "Shape_7" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_28/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_28/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_28/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_28" + op: "StridedSlice" + input: "t_natoms" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "Reshape_18/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "Reshape_18/shape/3" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "Reshape_18/shape" + op: "Pack" + input: "strided_slice_27" + input: "strided_slice_28" + input: "Reshape_18/shape/2" + input: "Reshape_18/shape/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_18" + op: "Reshape" + input: "MatMul_1" + input: "Reshape_18/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_16/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "mul_16" + op: "Mul" + input: "Reshape_18" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Shape_8" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_29/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_29/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_29/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_29" + op: "StridedSlice" + input: "Shape_8" + 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_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "strided_slice_30/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_30/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 3 + } + } + } +} +node { + name: "strided_slice_30/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_30" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_30/stack" + input: "strided_slice_30/stack_1" + input: "strided_slice_30/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "eye/ones/packed/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "eye/ones/packed" + op: "Pack" + input: "strided_slice_29" + input: "strided_slice_30" + input: "eye/ones/packed/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "eye/ones/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "eye/ones" + op: "Fill" + input: "eye/ones/packed" + input: "eye/ones/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "eye/diag/k" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "eye/diag/num_rows" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "eye/diag/num_cols" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "eye/diag/padding_value" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 0.0 + } + } + } +} +node { + name: "eye/diag" + op: "MatrixDiagV3" + input: "eye/ones" + input: "eye/diag/k" + input: "eye/diag/num_rows" + input: "eye/diag/num_cols" + input: "eye/diag/padding_value" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "align" + value { + s: "RIGHT_LEFT" + } + } +} +node { + name: "mul_17/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.9401135429382321 + } + } + } +} +node { + name: "mul_17" + op: "Mul" + input: "mul_17/x" + input: "eye/diag" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "add_7" + op: "AddV2" + input: "mul_16" + input: "mul_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "Reshape_21/shape" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_21" + op: "Reshape" + input: "add_7" + input: "Reshape_21/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "mul_22/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_22" + op: "Mul" + input: "add" + input: "mul_22/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "o_polar/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "o_polar/shape" + op: "Pack" + input: "o_polar/shape/0" + input: "mul_22" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "o_polar" + op: "Reshape" + input: "Reshape_21" + input: "o_polar/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_22/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_22/shape/2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "Reshape_22/shape" + op: "Pack" + input: "Reshape_22/shape/0" + input: "add" + input: "Reshape_22/shape/2" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_22" + op: "Reshape" + input: "o_polar" + input: "Reshape_22/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Sum/reduction_indices" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "Sum" + op: "Sum" + input: "Reshape_22" + input: "Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "o_global_polar/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "o_global_polar" + op: "Reshape" + input: "Sum" + input: "o_global_polar/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "split/split_dim" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "split" + op: "Split" + input: "split/split_dim" + input: "Reshape_22" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "num_split" + value { + i: 9 + } + } +} +node { + name: "gradients/Shape" + op: "Shape" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients/grad_ys_0" + op: "Fill" + input: "gradients/Shape" + input: "gradients/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/zeros_like" + op: "ZerosLike" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/zeros_like_1" + op: "ZerosLike" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/zeros_like_2" + op: "ZerosLike" + input: "split:3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/zeros_like_3" + op: "ZerosLike" + input: "split:4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/zeros_like_4" + op: "ZerosLike" + input: "split:5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/zeros_like_5" + op: "ZerosLike" + input: "split:6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/zeros_like_6" + op: "ZerosLike" + input: "split:7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/zeros_like_7" + op: "ZerosLike" + input: "split:8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/split_grad/concat" + op: "ConcatV2" + input: "gradients/grad_ys_0" + input: "gradients/zeros_like" + input: "gradients/zeros_like_1" + input: "gradients/zeros_like_2" + input: "gradients/zeros_like_3" + input: "gradients/zeros_like_4" + input: "gradients/zeros_like_5" + input: "gradients/zeros_like_6" + input: "gradients/zeros_like_7" + input: "split/split_dim" + attr { + key: "N" + value { + i: 9 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_22_grad/Shape" + op: "Shape" + input: "o_polar" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients/split_grad/concat" + input: "gradients/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/o_polar_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/o_polar_grad/Reshape" + op: "Reshape" + input: "gradients/Reshape_22_grad/Reshape" + input: "gradients/o_polar_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_21_grad/Shape" + op: "Shape" + input: "add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients/o_polar_grad/Reshape" + input: "gradients/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_7_grad/Shape" + op: "Shape" + input: "mul_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_7_grad/Shape_1" + op: "Shape" + input: "mul_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/add_7_grad/Shape" + input: "gradients/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_7_grad/Sum" + op: "Sum" + input: "gradients/Reshape_21_grad/Reshape" + input: "gradients/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_7_grad/Reshape" + op: "Reshape" + input: "gradients/add_7_grad/Sum" + input: "gradients/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/mul_16_grad/Shape" + op: "Shape" + input: "Reshape_18" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/mul_16_grad/Shape_1" + op: "Shape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/mul_16_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/mul_16_grad/Shape" + input: "gradients/mul_16_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/mul_16_grad/Mul" + op: "Mul" + input: "gradients/add_7_grad/Reshape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/mul_16_grad/Sum" + op: "Sum" + input: "gradients/mul_16_grad/Mul" + input: "gradients/mul_16_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/mul_16_grad/Reshape" + op: "Reshape" + input: "gradients/mul_16_grad/Sum" + input: "gradients/mul_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients/mul_16_grad/Reshape" + input: "gradients/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_1_grad/MatMul" + op: "BatchMatMulV2" + input: "MatMul" + input: "gradients/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/MatMul_1_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_16" + input: "gradients/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_1_grad/Shape" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_1_grad/Shape_1" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_1_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/MatMul_1_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/MatMul_1_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/MatMul_1_grad/strided_slice" + op: "StridedSlice" + input: "gradients/MatMul_1_grad/Shape" + input: "gradients/MatMul_1_grad/strided_slice/stack" + input: "gradients/MatMul_1_grad/strided_slice/stack_1" + input: "gradients/MatMul_1_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/MatMul_1_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/MatMul_1_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/MatMul_1_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/MatMul_1_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/MatMul_1_grad/Shape_1" + input: "gradients/MatMul_1_grad/strided_slice_1/stack" + input: "gradients/MatMul_1_grad/strided_slice_1/stack_1" + input: "gradients/MatMul_1_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/MatMul_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/MatMul_1_grad/strided_slice" + input: "gradients/MatMul_1_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_1_grad/Sum" + op: "Sum" + input: "gradients/MatMul_1_grad/MatMul" + input: "gradients/MatMul_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_1_grad/Reshape" + op: "Reshape" + input: "gradients/MatMul_1_grad/Sum" + input: "gradients/MatMul_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_1_grad/Sum_1" + op: "Sum" + input: "gradients/MatMul_1_grad/MatMul_1" + input: "gradients/MatMul_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_1_grad/Reshape_1" + op: "Reshape" + input: "gradients/MatMul_1_grad/Sum_1" + input: "gradients/MatMul_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients/MatMul_1_grad/Reshape_1" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "add_6" + input: "gradients/MatMul_1_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_grad/Shape" + op: "Shape" + input: "add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients/MatMul_grad/Shape" + input: "gradients/MatMul_grad/strided_slice/stack" + input: "gradients/MatMul_grad/strided_slice/stack_1" + input: "gradients/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/MatMul_grad/Shape_1" + input: "gradients/MatMul_grad/strided_slice_1/stack" + input: "gradients/MatMul_grad/strided_slice_1/stack_1" + input: "gradients/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/MatMul_grad/strided_slice" + input: "gradients/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/Sum" + op: "Sum" + input: "gradients/MatMul_grad/MatMul" + input: "gradients/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients/MatMul_grad/Sum" + input: "gradients/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients/MatMul_grad/MatMul_1" + input: "gradients/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients/MatMul_grad/Sum_1" + input: "gradients/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_6_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_6_grad/Shape_1" + op: "Shape" + input: "transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/add_6_grad/Shape" + input: "gradients/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_6_grad/Sum" + op: "Sum" + input: "gradients/MatMul_grad/Reshape" + input: "gradients/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_6_grad/Reshape" + op: "Reshape" + input: "gradients/add_6_grad/Sum" + input: "gradients/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_6_grad/Sum_1" + op: "Sum" + input: "gradients/MatMul_grad/Reshape" + input: "gradients/add_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_6_grad/Reshape_1" + op: "Reshape" + input: "gradients/add_6_grad/Sum_1" + input: "gradients/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN" + op: "AddN" + input: "gradients/MatMul_1_grad/Reshape" + input: "gradients/MatMul_grad/Reshape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/MatMul_1_grad/Reshape" + } + } + } +} +node { + name: "gradients/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients/AddN" + input: "gradients/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/transpose_grad/transpose" + op: "Transpose" + input: "gradients/add_6_grad/Reshape_1" + input: "gradients/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_3_grad/stack" + op: "Pack" + input: "gradients/Slice_3_grad/Rank" + input: "gradients/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/sub" + op: "Sub" + input: "gradients/Slice_3_grad/Shape_1" + input: "gradients/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/Slice_3_grad/sub_1" + input: "gradients/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients/Slice_3_grad/Reshape" + input: "gradients/Slice_3_grad/Reshape_1" + input: "gradients/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 + } + } +} +node { + name: "gradients/Slice_3_grad/Pad" + op: "Pad" + input: "gradients/Reshape_16_grad/Reshape" + input: "gradients/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_1" + op: "AddN" + input: "gradients/add_6_grad/Reshape" + input: "gradients/transpose_grad/transpose" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/add_6_grad/Reshape" + } + } + } +} +node { + name: "gradients/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_1" + input: "gradients/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients/Slice_3_grad/Pad" + input: "gradients/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/final_layer_type_0/add_grad/Shape" + input: "gradients/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/Reshape_17_grad/Reshape" + input: "gradients/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/final_layer_type_0/add_grad/Sum" + input: "gradients/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/concat_1_grad/mod" + input: "gradients/concat_1_grad/ShapeN" + input: "gradients/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/concat_1_grad/Slice" + op: "Slice" + input: "gradients/Reshape_14_grad/Reshape" + input: "gradients/concat_1_grad/ConcatOffset" + input: "gradients/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients/Reshape_14_grad/Reshape" + input: "gradients/concat_1_grad/ConcatOffset:1" + input: "gradients/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/add_5_grad/Shape" + op: "Shape" + input: "add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_5_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/add_5_grad/Shape" + input: "gradients/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_5_grad/Sum" + op: "Sum" + input: "gradients/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_5_grad/Reshape" + op: "Reshape" + input: "gradients/add_5_grad/Sum" + input: "gradients/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_5_grad/Sum_1" + op: "Sum" + input: "gradients/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients/add_5_grad/Sum_1" + input: "gradients/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients/concat_1_grad/Slice" + input: "gradients/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients/concat_1_grad/Slice_1" + input: "gradients/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_2_type_0/mul_grad/Shape" + input: "gradients/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients/add_5_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients/layer_2_type_0/mul_grad/Mul" + input: "gradients/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients/layer_2_type_0/mul_grad/Sum" + input: "gradients/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients/Reshape_8_grad/Reshape" + input: "gradients/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients/Reshape_12_grad/Reshape" + input: "gradients/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/layer_2_type_0/mul_grad/Reshape" + input: "gradients/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_5_grad/Rank" + input: "gradients/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_5_grad/sub_1" + input: "gradients/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_5_grad/Reshape" + input: "gradients/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients/filter_type_0/transpose_grad/transpose" + input: "gradients/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_5_grad/Rank" + input: "gradients/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_5_grad/sub_1" + input: "gradients/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_5_grad/Reshape" + input: "gradients/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients/filter_type_1/transpose_grad/transpose" + input: "gradients/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_2_type_0/add_grad/Shape" + input: "gradients/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/layer_2_type_0/add_grad/Sum" + input: "gradients/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/AddN_2" + op: "AddN" + input: "gradients/add_5_grad/Reshape" + input: "gradients/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients/add_4_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_4_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/add_4_grad/Shape" + input: "gradients/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_4_grad/Sum" + op: "Sum" + input: "gradients/AddN_2" + input: "gradients/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_4_grad/Reshape" + op: "Reshape" + input: "gradients/add_4_grad/Sum" + input: "gradients/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/add_4_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_2" + input: "gradients/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/add_4_grad/Sum_1" + input: "gradients/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_1_type_0/mul_grad/Shape" + input: "gradients/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients/add_4_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients/layer_1_type_0/mul_grad/Mul" + input: "gradients/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients/layer_1_type_0/mul_grad/Sum" + input: "gradients/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/layer_1_type_0/mul_grad/Reshape" + input: "gradients/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_1_type_0/add_grad/Shape" + input: "gradients/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/layer_1_type_0/add_grad/Sum" + input: "gradients/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/AddN_3" + op: "AddN" + input: "gradients/add_4_grad/Reshape" + input: "gradients/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_3" + input: "gradients/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/layer_0_type_0/add_grad/Shape" + input: "gradients/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/layer_0_type_0/add_grad/Sum" + input: "gradients/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_2_grad/stack" + op: "Pack" + input: "gradients/Slice_2_grad/Rank" + input: "gradients/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/sub" + op: "Sub" + input: "gradients/Slice_2_grad/Shape_1" + input: "gradients/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/Slice_2_grad/sub_1" + input: "gradients/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients/Slice_2_grad/Reshape" + input: "gradients/Slice_2_grad/Reshape_1" + input: "gradients/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 + } + } +} +node { + name: "gradients/Slice_2_grad/Pad" + op: "Pad" + input: "gradients/Reshape_15_grad/Reshape" + input: "gradients/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients/Slice_2_grad/Pad" + input: "gradients/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/concat_grad/mod" + input: "gradients/concat_grad/ShapeN" + input: "gradients/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/concat_grad/Slice" + op: "Slice" + input: "gradients/Reshape_13_grad/Reshape" + input: "gradients/concat_grad/ConcatOffset" + input: "gradients/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/concat_grad/Slice_1" + op: "Slice" + input: "gradients/Reshape_13_grad/Reshape" + input: "gradients/concat_grad/ConcatOffset:1" + input: "gradients/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients/concat_grad/Slice" + input: "gradients/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients/concat_grad/Slice_1" + input: "gradients/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients/Reshape_7_grad/Reshape" + input: "gradients/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients/Reshape_11_grad/Reshape" + input: "gradients/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_8_grad/Shape" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_8_grad/Sum" + input: "gradients/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_8_grad/Shape" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_8_grad/Sum" + input: "gradients/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_4_grad/Rank" + input: "gradients/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_4_grad/sub_1" + input: "gradients/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_4_grad/Reshape" + input: "gradients/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_4_grad/Rank" + input: "gradients/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_4_grad/sub_1" + input: "gradients/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_4_grad/Reshape" + input: "gradients/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_4" + op: "AddN" + input: "gradients/filter_type_0/Slice_5_grad/Pad" + input: "gradients/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/mul_grad/Shape" + input: "gradients/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients/AddN_4" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/mul_grad/Mul" + input: "gradients/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/mul_grad/Sum" + input: "gradients/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_5" + op: "AddN" + input: "gradients/filter_type_1/Slice_5_grad/Pad" + input: "gradients/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/mul_grad/Shape" + input: "gradients/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients/AddN_5" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/mul_grad/Mul" + input: "gradients/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/mul_grad/Sum" + input: "gradients/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_10_grad/Shape" + input: "gradients/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/mul_grad/Reshape" + input: "gradients/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_10_grad/Sum" + input: "gradients/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/mul_grad/Reshape" + input: "gradients/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_10_grad/Sum_1" + input: "gradients/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_10_grad/Shape" + input: "gradients/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/mul_grad/Reshape" + input: "gradients/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_10_grad/Sum" + input: "gradients/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/mul_grad/Reshape" + input: "gradients/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_10_grad/Sum_1" + input: "gradients/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_3_grad/Shape" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_3_grad/Sum" + input: "gradients/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_7_grad/Shape" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_7_grad/Sum" + input: "gradients/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_3_grad/Shape" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_3_grad/Sum" + input: "gradients/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_7_grad/Shape" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_7_grad/Sum" + input: "gradients/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_4_grad/Shape" + input: "gradients/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_4_grad/Sum" + input: "gradients/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_4_grad/Sum_1" + input: "gradients/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_9_grad/Shape" + input: "gradients/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_9_grad/Sum" + input: "gradients/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_9_grad/Sum_1" + input: "gradients/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_4_grad/Shape" + input: "gradients/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_4_grad/Sum" + input: "gradients/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_4_grad/Sum_1" + input: "gradients/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_9_grad/Shape" + input: "gradients/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_9_grad/Sum" + input: "gradients/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_9_grad/Sum_1" + input: "gradients/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_1/axis" + input: "gradients/filter_type_0/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_2" + input: "filter_type_0/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/filter_type_0/concat_1_grad/mod" + input: "gradients/filter_type_0/concat_1_grad/ShapeN" + input: "gradients/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/filter_type_0/concat_1_grad/Slice" + op: "Slice" + input: "gradients/filter_type_0/add_4_grad/Reshape" + input: "gradients/filter_type_0/concat_1_grad/ConcatOffset" + input: "gradients/filter_type_0/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients/filter_type_0/add_4_grad/Reshape" + input: "gradients/filter_type_0/concat_1_grad/ConcatOffset:1" + input: "gradients/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_4_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_3/axis" + input: "gradients/filter_type_0/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_7" + input: "filter_type_0/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/filter_type_0/concat_3_grad/mod" + input: "gradients/filter_type_0/concat_3_grad/ShapeN" + input: "gradients/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/filter_type_0/concat_3_grad/Slice" + op: "Slice" + input: "gradients/filter_type_0/add_9_grad/Reshape" + input: "gradients/filter_type_0/concat_3_grad/ConcatOffset" + input: "gradients/filter_type_0/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients/filter_type_0/add_9_grad/Reshape" + input: "gradients/filter_type_0/concat_3_grad/ConcatOffset:1" + input: "gradients/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_9_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_1/axis" + input: "gradients/filter_type_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_2" + input: "filter_type_1/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/filter_type_1/concat_1_grad/mod" + input: "gradients/filter_type_1/concat_1_grad/ShapeN" + input: "gradients/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/filter_type_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients/filter_type_1/add_4_grad/Reshape" + input: "gradients/filter_type_1/concat_1_grad/ConcatOffset" + input: "gradients/filter_type_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients/filter_type_1/add_4_grad/Reshape" + input: "gradients/filter_type_1/concat_1_grad/ConcatOffset:1" + input: "gradients/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_4_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_3/axis" + input: "gradients/filter_type_1/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_7" + input: "filter_type_1/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/filter_type_1/concat_3_grad/mod" + input: "gradients/filter_type_1/concat_3_grad/ShapeN" + input: "gradients/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/filter_type_1/concat_3_grad/Slice" + op: "Slice" + input: "gradients/filter_type_1/add_9_grad/Reshape" + input: "gradients/filter_type_1/concat_3_grad/ConcatOffset" + input: "gradients/filter_type_1/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients/filter_type_1/add_9_grad/Reshape" + input: "gradients/filter_type_1/concat_3_grad/ConcatOffset:1" + input: "gradients/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_9_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_3_grad/Shape" + input: "gradients/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_3_grad/Sum" + input: "gradients/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_8_grad/Shape" + input: "gradients/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_8_grad/Sum" + input: "gradients/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_3_grad/Shape" + input: "gradients/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_3_grad/Sum" + input: "gradients/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_8_grad/Shape" + input: "gradients/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_8_grad/Sum" + input: "gradients/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/AddN_6" + op: "AddN" + input: "gradients/filter_type_0/concat_1_grad/Slice" + input: "gradients/filter_type_0/concat_1_grad/Slice_1" + input: "gradients/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_2_grad/Shape" + input: "gradients/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients/AddN_6" + input: "gradients/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_2_grad/Sum" + input: "gradients/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_6" + input: "gradients/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_2_grad/Sum_1" + input: "gradients/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_7" + op: "AddN" + input: "gradients/filter_type_0/concat_3_grad/Slice" + input: "gradients/filter_type_0/concat_3_grad/Slice_1" + input: "gradients/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_7_grad/Shape" + input: "gradients/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients/AddN_7" + input: "gradients/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_7_grad/Sum" + input: "gradients/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_7" + input: "gradients/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/add_7_grad/Sum_1" + input: "gradients/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_8" + op: "AddN" + input: "gradients/filter_type_1/concat_1_grad/Slice" + input: "gradients/filter_type_1/concat_1_grad/Slice_1" + input: "gradients/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_2_grad/Shape" + input: "gradients/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients/AddN_8" + input: "gradients/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_2_grad/Sum" + input: "gradients/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_8" + input: "gradients/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_2_grad/Sum_1" + input: "gradients/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_9" + op: "AddN" + input: "gradients/filter_type_1/concat_3_grad/Slice" + input: "gradients/filter_type_1/concat_3_grad/Slice_1" + input: "gradients/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_7_grad/Shape" + input: "gradients/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients/AddN_9" + input: "gradients/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_7_grad/Sum" + input: "gradients/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients/AddN_9" + input: "gradients/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/add_7_grad/Sum_1" + input: "gradients/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/concat_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat/axis" + input: "gradients/filter_type_0/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/filter_type_0/concat_grad/mod" + input: "gradients/filter_type_0/concat_grad/ShapeN" + input: "gradients/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/filter_type_0/concat_grad/Slice" + op: "Slice" + input: "gradients/filter_type_0/add_2_grad/Reshape" + input: "gradients/filter_type_0/concat_grad/ConcatOffset" + input: "gradients/filter_type_0/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/concat_grad/Slice_1" + op: "Slice" + input: "gradients/filter_type_0/add_2_grad/Reshape" + input: "gradients/filter_type_0/concat_grad/ConcatOffset:1" + input: "gradients/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_2_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_2/axis" + input: "gradients/filter_type_0/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/filter_type_0/concat_2_grad/mod" + input: "gradients/filter_type_0/concat_2_grad/ShapeN" + input: "gradients/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/filter_type_0/concat_2_grad/Slice" + op: "Slice" + input: "gradients/filter_type_0/add_7_grad/Reshape" + input: "gradients/filter_type_0/concat_2_grad/ConcatOffset" + input: "gradients/filter_type_0/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients/filter_type_0/add_7_grad/Reshape" + input: "gradients/filter_type_0/concat_2_grad/ConcatOffset:1" + input: "gradients/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_7_grad/Reshape_1" + input: "gradients/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/concat_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat/axis" + input: "gradients/filter_type_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/filter_type_1/concat_grad/mod" + input: "gradients/filter_type_1/concat_grad/ShapeN" + input: "gradients/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/filter_type_1/concat_grad/Slice" + op: "Slice" + input: "gradients/filter_type_1/add_2_grad/Reshape" + input: "gradients/filter_type_1/concat_grad/ConcatOffset" + input: "gradients/filter_type_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients/filter_type_1/add_2_grad/Reshape" + input: "gradients/filter_type_1/concat_grad/ConcatOffset:1" + input: "gradients/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_2_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_2/axis" + input: "gradients/filter_type_1/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients/filter_type_1/concat_2_grad/mod" + input: "gradients/filter_type_1/concat_2_grad/ShapeN" + input: "gradients/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients/filter_type_1/concat_2_grad/Slice" + op: "Slice" + input: "gradients/filter_type_1/add_7_grad/Reshape" + input: "gradients/filter_type_1/concat_2_grad/ConcatOffset" + input: "gradients/filter_type_1/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients/filter_type_1/add_7_grad/Reshape" + input: "gradients/filter_type_1/concat_2_grad/ConcatOffset:1" + input: "gradients/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_7_grad/Reshape_1" + input: "gradients/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_1_grad/Shape" + input: "gradients/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_1_grad/Sum" + input: "gradients/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_6_grad/Shape" + input: "gradients/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_6_grad/Sum" + input: "gradients/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_1_grad/Shape" + input: "gradients/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_1_grad/Sum" + input: "gradients/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_6_grad/Shape" + input: "gradients/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_6_grad/Sum" + input: "gradients/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/AddN_10" + op: "AddN" + input: "gradients/filter_type_0/concat_grad/Slice" + input: "gradients/filter_type_0/concat_grad/Slice_1" + input: "gradients/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/concat_grad/Slice" + } + } + } +} +node { + name: "gradients/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_10" + input: "gradients/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_11" + op: "AddN" + input: "gradients/filter_type_0/concat_2_grad/Slice" + input: "gradients/filter_type_0/concat_2_grad/Slice_1" + input: "gradients/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_11" + input: "gradients/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_12" + op: "AddN" + input: "gradients/filter_type_1/concat_grad/Slice" + input: "gradients/filter_type_1/concat_grad/Slice_1" + input: "gradients/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/concat_grad/Slice" + } + } + } +} +node { + name: "gradients/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_12" + input: "gradients/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_13" + op: "AddN" + input: "gradients/filter_type_1/concat_2_grad/Slice" + input: "gradients/filter_type_1/concat_2_grad/Slice_1" + input: "gradients/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_13" + input: "gradients/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_grad/Shape" + input: "gradients/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_grad/Sum" + input: "gradients/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_0/add_5_grad/Shape" + input: "gradients/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/add_5_grad/Sum" + input: "gradients/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_grad/Shape" + input: "gradients/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_grad/Sum" + input: "gradients/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients/filter_type_1/add_5_grad/Shape" + input: "gradients/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/add_5_grad/Sum" + input: "gradients/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_grad/MatMul" + input: "gradients/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_grad/MatMul" + input: "gradients/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_1_grad/Rank" + input: "gradients/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_1_grad/sub_1" + input: "gradients/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_1_grad/Reshape" + input: "gradients/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_3_grad/Rank" + input: "gradients/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_3_grad/sub_1" + input: "gradients/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_3_grad/Reshape" + input: "gradients/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_1_grad/Rank" + input: "gradients/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_1_grad/sub_1" + input: "gradients/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_1_grad/Reshape" + input: "gradients/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_3_grad/Rank" + input: "gradients/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_3_grad/sub_1" + input: "gradients/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_3_grad/Reshape" + input: "gradients/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/Slice_1_grad/Pad" + input: "gradients/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_0/Slice_3_grad/Pad" + input: "gradients/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/Slice_1_grad/Pad" + input: "gradients/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients/filter_type_1/Slice_3_grad/Pad" + input: "gradients/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_14" + op: "AddN" + input: "gradients/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_grad/Rank" + input: "gradients/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_grad/Shape_1" + input: "gradients/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_grad/sub_1" + input: "gradients/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_grad/Reshape" + input: "gradients/filter_type_0/Slice_grad/Reshape_1" + input: "gradients/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients/AddN_14" + input: "gradients/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_15" + op: "AddN" + input: "gradients/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients/filter_type_0/Slice_2_grad/Rank" + input: "gradients/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_0/Slice_2_grad/sub_1" + input: "gradients/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_0/Slice_2_grad/Reshape" + input: "gradients/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients/filter_type_0/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 + } + } +} +node { + name: "gradients/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients/AddN_15" + input: "gradients/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_16" + op: "AddN" + input: "gradients/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_grad/Rank" + input: "gradients/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_grad/Shape_1" + input: "gradients/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_grad/sub_1" + input: "gradients/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_grad/Reshape" + input: "gradients/filter_type_1/Slice_grad/Reshape_1" + input: "gradients/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients/AddN_16" + input: "gradients/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_17" + op: "AddN" + input: "gradients/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients/filter_type_1/Slice_2_grad/Rank" + input: "gradients/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients/filter_type_1/Slice_2_grad/sub_1" + input: "gradients/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients/filter_type_1/Slice_2_grad/Reshape" + input: "gradients/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients/filter_type_1/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 + } + } +} +node { + name: "gradients/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients/AddN_17" + input: "gradients/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_18" + op: "AddN" + input: "gradients/filter_type_0/Slice_grad/Pad" + input: "gradients/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_18" + input: "gradients/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_19" + op: "AddN" + input: "gradients/filter_type_1/Slice_grad/Pad" + input: "gradients/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_19" + input: "gradients/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_grad/stack" + op: "Pack" + input: "gradients/Slice_grad/Rank" + input: "gradients/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/sub" + op: "Sub" + input: "gradients/Slice_grad/Shape_1" + input: "gradients/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/sub_1" + op: "Sub" + input: "gradients/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients/Slice_grad/sub_1" + input: "gradients/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_grad/concat" + op: "ConcatV2" + input: "gradients/Slice_grad/Reshape" + input: "gradients/Slice_grad/Reshape_1" + input: "gradients/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_grad/Pad" + op: "Pad" + input: "gradients/Reshape_5_grad/Reshape" + input: "gradients/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_1_grad/stack" + op: "Pack" + input: "gradients/Slice_1_grad/Rank" + input: "gradients/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/sub" + op: "Sub" + input: "gradients/Slice_1_grad/Shape_1" + input: "gradients/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients/Slice_1_grad/sub_1" + input: "gradients/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients/Slice_1_grad/Reshape" + input: "gradients/Slice_1_grad/Reshape_1" + input: "gradients/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 + } + } +} +node { + name: "gradients/Slice_1_grad/Pad" + op: "Pad" + input: "gradients/Reshape_9_grad/Reshape" + input: "gradients/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/AddN_20" + op: "AddN" + input: "gradients/Slice_grad/Pad" + input: "gradients/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients/AddN_20" + input: "gradients/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_34/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_34/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_34/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_34" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_34/stack" + input: "strided_slice_34/stack_1" + input: "strided_slice_34/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_23/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_23" + op: "Mul" + input: "strided_slice_34" + input: "mul_23/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_23/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_23/shape" + op: "Pack" + input: "Reshape_23/shape/0" + input: "mul_23" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_23" + op: "Reshape" + input: "gradients/Reshape_4_grad/Reshape" + input: "Reshape_23/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA" + op: "ProdForceSeA" + input: "Reshape_23" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA" + op: "ProdVirialSeA" + input: "Reshape_23" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_35/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_35/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_35/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_35" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_35/stack" + input: "strided_slice_35/stack_1" + input: "strided_slice_35/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_24/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_24" + op: "Mul" + input: "mul_24/x" + input: "strided_slice_35" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_24/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_24/shape" + op: "Pack" + input: "Reshape_24/shape/0" + input: "mul_24" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_24" + op: "Reshape" + input: "ProdForceSeA" + input: "Reshape_24/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_25/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_25" + op: "Reshape" + input: "ProdVirialSeA" + input: "Reshape_25/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_36/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_36/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_36/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_36" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_36/stack" + input: "strided_slice_36/stack_1" + input: "strided_slice_36/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_25/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_25" + op: "Mul" + input: "mul_25/x" + input: "strided_slice_36" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_26/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_26/shape" + op: "Pack" + input: "Reshape_26/shape/0" + input: "mul_25" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_26" + op: "Reshape" + input: "ProdVirialSeA:1" + input: "Reshape_26/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Shape" + op: "Shape" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients_1/grad_ys_0" + op: "Fill" + input: "gradients_1/Shape" + input: "gradients_1/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/zeros_like" + op: "ZerosLike" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/zeros_like_1" + op: "ZerosLike" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/zeros_like_2" + op: "ZerosLike" + input: "split:3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/zeros_like_3" + op: "ZerosLike" + input: "split:4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/zeros_like_4" + op: "ZerosLike" + input: "split:5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/zeros_like_5" + op: "ZerosLike" + input: "split:6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/zeros_like_6" + op: "ZerosLike" + input: "split:7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/zeros_like_7" + op: "ZerosLike" + input: "split:8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/split_grad/concat" + op: "ConcatV2" + input: "gradients_1/zeros_like" + input: "gradients_1/grad_ys_0" + input: "gradients_1/zeros_like_1" + input: "gradients_1/zeros_like_2" + input: "gradients_1/zeros_like_3" + input: "gradients_1/zeros_like_4" + input: "gradients_1/zeros_like_5" + input: "gradients_1/zeros_like_6" + input: "gradients_1/zeros_like_7" + input: "split/split_dim" + attr { + key: "N" + value { + i: 9 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_22_grad/Shape" + op: "Shape" + input: "o_polar" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients_1/split_grad/concat" + input: "gradients_1/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/o_polar_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/o_polar_grad/Reshape" + op: "Reshape" + input: "gradients_1/Reshape_22_grad/Reshape" + input: "gradients_1/o_polar_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_21_grad/Shape" + op: "Shape" + input: "add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients_1/o_polar_grad/Reshape" + input: "gradients_1/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_7_grad/Shape" + op: "Shape" + input: "mul_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_7_grad/Shape_1" + op: "Shape" + input: "mul_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/add_7_grad/Shape" + input: "gradients_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_7_grad/Sum" + op: "Sum" + input: "gradients_1/Reshape_21_grad/Reshape" + input: "gradients_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/add_7_grad/Sum" + input: "gradients_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/mul_16_grad/Shape" + op: "Shape" + input: "Reshape_18" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/mul_16_grad/Shape_1" + op: "Shape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/mul_16_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/mul_16_grad/Shape" + input: "gradients_1/mul_16_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/mul_16_grad/Mul" + op: "Mul" + input: "gradients_1/add_7_grad/Reshape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/mul_16_grad/Sum" + op: "Sum" + input: "gradients_1/mul_16_grad/Mul" + input: "gradients_1/mul_16_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/mul_16_grad/Reshape" + op: "Reshape" + input: "gradients_1/mul_16_grad/Sum" + input: "gradients_1/mul_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients_1/mul_16_grad/Reshape" + input: "gradients_1/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_1_grad/MatMul" + op: "BatchMatMulV2" + input: "MatMul" + input: "gradients_1/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/MatMul_1_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_16" + input: "gradients_1/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_1_grad/Shape" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_1_grad/Shape_1" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_1_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/MatMul_1_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/MatMul_1_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/MatMul_1_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/MatMul_1_grad/Shape" + input: "gradients_1/MatMul_1_grad/strided_slice/stack" + input: "gradients_1/MatMul_1_grad/strided_slice/stack_1" + input: "gradients_1/MatMul_1_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/MatMul_1_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/MatMul_1_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/MatMul_1_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/MatMul_1_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/MatMul_1_grad/Shape_1" + input: "gradients_1/MatMul_1_grad/strided_slice_1/stack" + input: "gradients_1/MatMul_1_grad/strided_slice_1/stack_1" + input: "gradients_1/MatMul_1_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/MatMul_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/MatMul_1_grad/strided_slice" + input: "gradients_1/MatMul_1_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_1_grad/Sum" + op: "Sum" + input: "gradients_1/MatMul_1_grad/MatMul" + input: "gradients_1/MatMul_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_1_grad/Reshape" + op: "Reshape" + input: "gradients_1/MatMul_1_grad/Sum" + input: "gradients_1/MatMul_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_1_grad/Sum_1" + op: "Sum" + input: "gradients_1/MatMul_1_grad/MatMul_1" + input: "gradients_1/MatMul_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/MatMul_1_grad/Sum_1" + input: "gradients_1/MatMul_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients_1/MatMul_1_grad/Reshape_1" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "add_6" + input: "gradients_1/MatMul_1_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_grad/Shape" + op: "Shape" + input: "add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/MatMul_grad/Shape" + input: "gradients_1/MatMul_grad/strided_slice/stack" + input: "gradients_1/MatMul_grad/strided_slice/stack_1" + input: "gradients_1/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/MatMul_grad/Shape_1" + input: "gradients_1/MatMul_grad/strided_slice_1/stack" + input: "gradients_1/MatMul_grad/strided_slice_1/stack_1" + input: "gradients_1/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/MatMul_grad/strided_slice" + input: "gradients_1/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/Sum" + op: "Sum" + input: "gradients_1/MatMul_grad/MatMul" + input: "gradients_1/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients_1/MatMul_grad/Sum" + input: "gradients_1/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients_1/MatMul_grad/MatMul_1" + input: "gradients_1/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/MatMul_grad/Sum_1" + input: "gradients_1/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_6_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_6_grad/Shape_1" + op: "Shape" + input: "transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/add_6_grad/Shape" + input: "gradients_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_6_grad/Sum" + op: "Sum" + input: "gradients_1/MatMul_grad/Reshape" + input: "gradients_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_1/add_6_grad/Sum" + input: "gradients_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_6_grad/Sum_1" + op: "Sum" + input: "gradients_1/MatMul_grad/Reshape" + input: "gradients_1/add_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_6_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/add_6_grad/Sum_1" + input: "gradients_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN" + op: "AddN" + input: "gradients_1/MatMul_1_grad/Reshape" + input: "gradients_1/MatMul_grad/Reshape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/MatMul_1_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN" + input: "gradients_1/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients_1/add_6_grad/Reshape_1" + input: "gradients_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_1/Slice_3_grad/Rank" + input: "gradients_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_1/Slice_3_grad/Shape_1" + input: "gradients_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_1/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/Slice_3_grad/sub_1" + input: "gradients_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_1/Slice_3_grad/Reshape" + input: "gradients_1/Slice_3_grad/Reshape_1" + input: "gradients_1/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 + } + } +} +node { + name: "gradients_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_1/Reshape_16_grad/Reshape" + input: "gradients_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_1" + op: "AddN" + input: "gradients_1/add_6_grad/Reshape" + input: "gradients_1/transpose_grad/transpose" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/add_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_1" + input: "gradients_1/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_1/Slice_3_grad/Pad" + input: "gradients_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/final_layer_type_0/add_grad/Shape" + input: "gradients_1/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/Reshape_17_grad/Reshape" + input: "gradients_1/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/final_layer_type_0/add_grad/Sum" + input: "gradients_1/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/concat_1_grad/mod" + input: "gradients_1/concat_1_grad/ShapeN" + input: "gradients_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients_1/Reshape_14_grad/Reshape" + input: "gradients_1/concat_1_grad/ConcatOffset" + input: "gradients_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_1/Reshape_14_grad/Reshape" + input: "gradients_1/concat_1_grad/ConcatOffset:1" + input: "gradients_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/add_5_grad/Shape" + op: "Shape" + input: "add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_5_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/add_5_grad/Shape" + input: "gradients_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_1/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/add_5_grad/Sum" + input: "gradients_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_5_grad/Sum_1" + op: "Sum" + input: "gradients_1/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_1/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/add_5_grad/Sum_1" + input: "gradients_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/concat_1_grad/Slice" + input: "gradients_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_1/concat_1_grad/Slice_1" + input: "gradients_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_2_type_0/mul_grad/Shape" + input: "gradients_1/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_1/add_5_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_1/layer_2_type_0/mul_grad/Mul" + input: "gradients_1/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_2_type_0/mul_grad/Sum" + input: "gradients_1/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients_1/Reshape_8_grad/Reshape" + input: "gradients_1/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients_1/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_2_type_0/mul_grad/Reshape" + input: "gradients_1/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_5_grad/Rank" + input: "gradients_1/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients_1/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_5_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_5_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_0/transpose_grad/transpose" + input: "gradients_1/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_5_grad/Rank" + input: "gradients_1/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients_1/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_5_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_5_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_1/transpose_grad/transpose" + input: "gradients_1/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients_1/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_2_type_0/add_grad/Shape" + input: "gradients_1/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients_1/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_2_type_0/add_grad/Sum" + input: "gradients_1/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/AddN_2" + op: "AddN" + input: "gradients_1/add_5_grad/Reshape" + input: "gradients_1/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/add_4_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_4_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/add_4_grad/Shape" + input: "gradients_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_4_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_2" + input: "gradients_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/add_4_grad/Sum" + input: "gradients_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_2" + input: "gradients_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/add_4_grad/Sum_1" + input: "gradients_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_1_type_0/mul_grad/Shape" + input: "gradients_1/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_1/add_4_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_1/layer_1_type_0/mul_grad/Mul" + input: "gradients_1/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_1_type_0/mul_grad/Sum" + input: "gradients_1/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_1_type_0/mul_grad/Reshape" + input: "gradients_1/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients_1/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_1_type_0/add_grad/Shape" + input: "gradients_1/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients_1/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_1_type_0/add_grad/Sum" + input: "gradients_1/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/AddN_3" + op: "AddN" + input: "gradients_1/add_4_grad/Reshape" + input: "gradients_1/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_3" + input: "gradients_1/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients_1/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/layer_0_type_0/add_grad/Shape" + input: "gradients_1/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients_1/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_0_type_0/add_grad/Sum" + input: "gradients_1/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients_1/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients_1/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_1/Slice_2_grad/Rank" + input: "gradients_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_1/Slice_2_grad/Shape_1" + input: "gradients_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_1/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/Slice_2_grad/sub_1" + input: "gradients_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_1/Slice_2_grad/Reshape" + input: "gradients_1/Slice_2_grad/Reshape_1" + input: "gradients_1/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 + } + } +} +node { + name: "gradients_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_1/Reshape_15_grad/Reshape" + input: "gradients_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_1/Slice_2_grad/Pad" + input: "gradients_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/concat_grad/mod" + input: "gradients_1/concat_grad/ShapeN" + input: "gradients_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/concat_grad/Slice" + op: "Slice" + input: "gradients_1/Reshape_13_grad/Reshape" + input: "gradients_1/concat_grad/ConcatOffset" + input: "gradients_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients_1/Reshape_13_grad/Reshape" + input: "gradients_1/concat_grad/ConcatOffset:1" + input: "gradients_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/concat_grad/Slice" + input: "gradients_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_1/concat_grad/Slice_1" + input: "gradients_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_1/Reshape_7_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_1/Reshape_11_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients_1/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients_1/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_8_grad/Shape" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients_1/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients_1/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_8_grad/Sum" + input: "gradients_1/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients_1/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients_1/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients_1/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_8_grad/Shape" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients_1/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients_1/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_8_grad/Sum" + input: "gradients_1/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients_1/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_4_grad/Rank" + input: "gradients_1/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients_1/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_4_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_4_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients_1/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_4_grad/Rank" + input: "gradients_1/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients_1/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_4_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_4_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients_1/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_4" + op: "AddN" + input: "gradients_1/filter_type_0/Slice_5_grad/Pad" + input: "gradients_1/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/mul_grad/Shape" + input: "gradients_1/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_1/AddN_4" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/mul_grad/Mul" + input: "gradients_1/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/mul_grad/Sum" + input: "gradients_1/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_5" + op: "AddN" + input: "gradients_1/filter_type_1/Slice_5_grad/Pad" + input: "gradients_1/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/mul_grad/Shape" + input: "gradients_1/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_1/AddN_5" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/mul_grad/Mul" + input: "gradients_1/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/mul_grad/Sum" + input: "gradients_1/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_10_grad/Shape" + input: "gradients_1/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/mul_grad/Reshape" + input: "gradients_1/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_10_grad/Sum" + input: "gradients_1/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/mul_grad/Reshape" + input: "gradients_1/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_10_grad/Sum_1" + input: "gradients_1/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_10_grad/Shape" + input: "gradients_1/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/mul_grad/Reshape" + input: "gradients_1/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_10_grad/Sum" + input: "gradients_1/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/mul_grad/Reshape" + input: "gradients_1/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_10_grad/Sum_1" + input: "gradients_1/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients_1/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients_1/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_3_grad/Shape" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients_1/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients_1/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_3_grad/Sum" + input: "gradients_1/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients_1/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients_1/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients_1/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_7_grad/Shape" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients_1/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients_1/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_7_grad/Sum" + input: "gradients_1/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients_1/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients_1/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients_1/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_3_grad/Shape" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients_1/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients_1/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_3_grad/Sum" + input: "gradients_1/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients_1/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients_1/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients_1/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_7_grad/Shape" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_1/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_1/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients_1/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients_1/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_7_grad/Sum" + input: "gradients_1/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients_1/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_4_grad/Shape" + input: "gradients_1/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_1/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_4_grad/Sum" + input: "gradients_1/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_1/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_4_grad/Sum_1" + input: "gradients_1/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_9_grad/Shape" + input: "gradients_1/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_9_grad/Sum" + input: "gradients_1/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_9_grad/Sum_1" + input: "gradients_1/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_4_grad/Shape" + input: "gradients_1/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_1/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_4_grad/Sum" + input: "gradients_1/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_1/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_4_grad/Sum_1" + input: "gradients_1/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_9_grad/Shape" + input: "gradients_1/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_9_grad/Sum" + input: "gradients_1/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_1/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_1/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_9_grad/Sum_1" + input: "gradients_1/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_1/axis" + input: "gradients_1/filter_type_0/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_2" + input: "filter_type_0/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/filter_type_0/concat_1_grad/mod" + input: "gradients_1/filter_type_0/concat_1_grad/ShapeN" + input: "gradients_1/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_1_grad/Slice" + op: "Slice" + input: "gradients_1/filter_type_0/add_4_grad/Reshape" + input: "gradients_1/filter_type_0/concat_1_grad/ConcatOffset" + input: "gradients_1/filter_type_0/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_1/filter_type_0/add_4_grad/Reshape" + input: "gradients_1/filter_type_0/concat_1_grad/ConcatOffset:1" + input: "gradients_1/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_4_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_3/axis" + input: "gradients_1/filter_type_0/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_7" + input: "filter_type_0/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/filter_type_0/concat_3_grad/mod" + input: "gradients_1/filter_type_0/concat_3_grad/ShapeN" + input: "gradients_1/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_3_grad/Slice" + op: "Slice" + input: "gradients_1/filter_type_0/add_9_grad/Reshape" + input: "gradients_1/filter_type_0/concat_3_grad/ConcatOffset" + input: "gradients_1/filter_type_0/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_1/filter_type_0/add_9_grad/Reshape" + input: "gradients_1/filter_type_0/concat_3_grad/ConcatOffset:1" + input: "gradients_1/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_9_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_1/axis" + input: "gradients_1/filter_type_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_2" + input: "filter_type_1/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/filter_type_1/concat_1_grad/mod" + input: "gradients_1/filter_type_1/concat_1_grad/ShapeN" + input: "gradients_1/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients_1/filter_type_1/add_4_grad/Reshape" + input: "gradients_1/filter_type_1/concat_1_grad/ConcatOffset" + input: "gradients_1/filter_type_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_1/filter_type_1/add_4_grad/Reshape" + input: "gradients_1/filter_type_1/concat_1_grad/ConcatOffset:1" + input: "gradients_1/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_4_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_3/axis" + input: "gradients_1/filter_type_1/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_7" + input: "filter_type_1/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/filter_type_1/concat_3_grad/mod" + input: "gradients_1/filter_type_1/concat_3_grad/ShapeN" + input: "gradients_1/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_3_grad/Slice" + op: "Slice" + input: "gradients_1/filter_type_1/add_9_grad/Reshape" + input: "gradients_1/filter_type_1/concat_3_grad/ConcatOffset" + input: "gradients_1/filter_type_1/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_1/filter_type_1/add_9_grad/Reshape" + input: "gradients_1/filter_type_1/concat_3_grad/ConcatOffset:1" + input: "gradients_1/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_9_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients_1/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients_1/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients_1/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients_1/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_3_grad/Shape" + input: "gradients_1/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_3_grad/Sum" + input: "gradients_1/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_8_grad/Shape" + input: "gradients_1/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_8_grad/Sum" + input: "gradients_1/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_3_grad/Shape" + input: "gradients_1/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_3_grad/Sum" + input: "gradients_1/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_8_grad/Shape" + input: "gradients_1/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_8_grad/Sum" + input: "gradients_1/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/AddN_6" + op: "AddN" + input: "gradients_1/filter_type_0/concat_1_grad/Slice" + input: "gradients_1/filter_type_0/concat_1_grad/Slice_1" + input: "gradients_1/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_2_grad/Shape" + input: "gradients_1/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_6" + input: "gradients_1/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_2_grad/Sum" + input: "gradients_1/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_6" + input: "gradients_1/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_2_grad/Sum_1" + input: "gradients_1/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_7" + op: "AddN" + input: "gradients_1/filter_type_0/concat_3_grad/Slice" + input: "gradients_1/filter_type_0/concat_3_grad/Slice_1" + input: "gradients_1/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_7_grad/Shape" + input: "gradients_1/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_7" + input: "gradients_1/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_7_grad/Sum" + input: "gradients_1/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_7" + input: "gradients_1/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/add_7_grad/Sum_1" + input: "gradients_1/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_8" + op: "AddN" + input: "gradients_1/filter_type_1/concat_1_grad/Slice" + input: "gradients_1/filter_type_1/concat_1_grad/Slice_1" + input: "gradients_1/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_2_grad/Shape" + input: "gradients_1/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_8" + input: "gradients_1/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_2_grad/Sum" + input: "gradients_1/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_8" + input: "gradients_1/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_2_grad/Sum_1" + input: "gradients_1/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_9" + op: "AddN" + input: "gradients_1/filter_type_1/concat_3_grad/Slice" + input: "gradients_1/filter_type_1/concat_3_grad/Slice_1" + input: "gradients_1/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_7_grad/Shape" + input: "gradients_1/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients_1/AddN_9" + input: "gradients_1/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_7_grad/Sum" + input: "gradients_1/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_1/AddN_9" + input: "gradients_1/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/add_7_grad/Sum_1" + input: "gradients_1/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/concat_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat/axis" + input: "gradients_1/filter_type_0/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/filter_type_0/concat_grad/mod" + input: "gradients_1/filter_type_0/concat_grad/ShapeN" + input: "gradients_1/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_grad/Slice" + op: "Slice" + input: "gradients_1/filter_type_0/add_2_grad/Reshape" + input: "gradients_1/filter_type_0/concat_grad/ConcatOffset" + input: "gradients_1/filter_type_0/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/concat_grad/Slice_1" + op: "Slice" + input: "gradients_1/filter_type_0/add_2_grad/Reshape" + input: "gradients_1/filter_type_0/concat_grad/ConcatOffset:1" + input: "gradients_1/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_2_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_2/axis" + input: "gradients_1/filter_type_0/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/filter_type_0/concat_2_grad/mod" + input: "gradients_1/filter_type_0/concat_2_grad/ShapeN" + input: "gradients_1/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/filter_type_0/concat_2_grad/Slice" + op: "Slice" + input: "gradients_1/filter_type_0/add_7_grad/Reshape" + input: "gradients_1/filter_type_0/concat_2_grad/ConcatOffset" + input: "gradients_1/filter_type_0/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_1/filter_type_0/add_7_grad/Reshape" + input: "gradients_1/filter_type_0/concat_2_grad/ConcatOffset:1" + input: "gradients_1/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_7_grad/Reshape_1" + input: "gradients_1/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/concat_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat/axis" + input: "gradients_1/filter_type_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/filter_type_1/concat_grad/mod" + input: "gradients_1/filter_type_1/concat_grad/ShapeN" + input: "gradients_1/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_grad/Slice" + op: "Slice" + input: "gradients_1/filter_type_1/add_2_grad/Reshape" + input: "gradients_1/filter_type_1/concat_grad/ConcatOffset" + input: "gradients_1/filter_type_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients_1/filter_type_1/add_2_grad/Reshape" + input: "gradients_1/filter_type_1/concat_grad/ConcatOffset:1" + input: "gradients_1/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_2_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_2/axis" + input: "gradients_1/filter_type_1/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_1/filter_type_1/concat_2_grad/mod" + input: "gradients_1/filter_type_1/concat_2_grad/ShapeN" + input: "gradients_1/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_1/filter_type_1/concat_2_grad/Slice" + op: "Slice" + input: "gradients_1/filter_type_1/add_7_grad/Reshape" + input: "gradients_1/filter_type_1/concat_2_grad/ConcatOffset" + input: "gradients_1/filter_type_1/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_1/filter_type_1/add_7_grad/Reshape" + input: "gradients_1/filter_type_1/concat_2_grad/ConcatOffset:1" + input: "gradients_1/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_7_grad/Reshape_1" + input: "gradients_1/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients_1/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients_1/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients_1/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients_1/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_1_grad/Shape" + input: "gradients_1/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_1_grad/Sum" + input: "gradients_1/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_6_grad/Shape" + input: "gradients_1/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_6_grad/Sum" + input: "gradients_1/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_1_grad/Shape" + input: "gradients_1/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_1_grad/Sum" + input: "gradients_1/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_6_grad/Shape" + input: "gradients_1/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_6_grad/Sum" + input: "gradients_1/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/AddN_10" + op: "AddN" + input: "gradients_1/filter_type_0/concat_grad/Slice" + input: "gradients_1/filter_type_0/concat_grad/Slice_1" + input: "gradients_1/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_10" + input: "gradients_1/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_11" + op: "AddN" + input: "gradients_1/filter_type_0/concat_2_grad/Slice" + input: "gradients_1/filter_type_0/concat_2_grad/Slice_1" + input: "gradients_1/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_11" + input: "gradients_1/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_12" + op: "AddN" + input: "gradients_1/filter_type_1/concat_grad/Slice" + input: "gradients_1/filter_type_1/concat_grad/Slice_1" + input: "gradients_1/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_12" + input: "gradients_1/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_13" + op: "AddN" + input: "gradients_1/filter_type_1/concat_2_grad/Slice" + input: "gradients_1/filter_type_1/concat_2_grad/Slice_1" + input: "gradients_1/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_13" + input: "gradients_1/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients_1/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients_1/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients_1/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients_1/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_grad/Shape" + input: "gradients_1/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_grad/Sum" + input: "gradients_1/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_0/add_5_grad/Shape" + input: "gradients_1/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients_1/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/add_5_grad/Sum" + input: "gradients_1/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_grad/Shape" + input: "gradients_1/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_grad/Sum" + input: "gradients_1/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_1/filter_type_1/add_5_grad/Shape" + input: "gradients_1/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_1/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients_1/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_1/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/add_5_grad/Sum" + input: "gradients_1/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_1/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_grad/MatMul" + input: "gradients_1/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients_1/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_grad/MatMul" + input: "gradients_1/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients_1/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_1_grad/Rank" + input: "gradients_1/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients_1/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_1_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_1_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_3_grad/Rank" + input: "gradients_1/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients_1/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_3_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_3_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_1_grad/Rank" + input: "gradients_1/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients_1/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_1_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_1_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_3_grad/Rank" + input: "gradients_1/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients_1/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_3_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_3_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_1/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_1_grad/Pad" + input: "gradients_1/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_3_grad/Pad" + input: "gradients_1/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_1_grad/Pad" + input: "gradients_1/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_3_grad/Pad" + input: "gradients_1/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_14" + op: "AddN" + input: "gradients_1/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_grad/Rank" + input: "gradients_1/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients_1/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_grad/Reshape_1" + input: "gradients_1/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients_1/AddN_14" + input: "gradients_1/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_15" + op: "AddN" + input: "gradients_1/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients_1/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_0/Slice_2_grad/Rank" + input: "gradients_1/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients_1/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients_1/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_0/Slice_2_grad/sub_1" + input: "gradients_1/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_0/Slice_2_grad/Reshape" + input: "gradients_1/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients_1/filter_type_0/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 + } + } +} +node { + name: "gradients_1/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_1/AddN_15" + input: "gradients_1/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_16" + op: "AddN" + input: "gradients_1/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_grad/Rank" + input: "gradients_1/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients_1/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_grad/Reshape_1" + input: "gradients_1/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_1/AddN_16" + input: "gradients_1/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_17" + op: "AddN" + input: "gradients_1/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients_1/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_1/filter_type_1/Slice_2_grad/Rank" + input: "gradients_1/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients_1/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients_1/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_1/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/filter_type_1/Slice_2_grad/sub_1" + input: "gradients_1/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_1/filter_type_1/Slice_2_grad/Reshape" + input: "gradients_1/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients_1/filter_type_1/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 + } + } +} +node { + name: "gradients_1/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_1/AddN_17" + input: "gradients_1/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_18" + op: "AddN" + input: "gradients_1/filter_type_0/Slice_grad/Pad" + input: "gradients_1/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_1/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_18" + input: "gradients_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_19" + op: "AddN" + input: "gradients_1/filter_type_1/Slice_grad/Pad" + input: "gradients_1/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_1/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_19" + input: "gradients_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_grad/stack" + op: "Pack" + input: "gradients_1/Slice_grad/Rank" + input: "gradients_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/sub" + op: "Sub" + input: "gradients_1/Slice_grad/Shape_1" + input: "gradients_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_1/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/Slice_grad/sub_1" + input: "gradients_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_1/Slice_grad/Reshape" + input: "gradients_1/Slice_grad/Reshape_1" + input: "gradients_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_1/Reshape_5_grad/Reshape" + input: "gradients_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_1/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_1/Slice_1_grad/Rank" + input: "gradients_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_1/Slice_1_grad/Shape_1" + input: "gradients_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_1/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_1/Slice_1_grad/sub_1" + input: "gradients_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_1/Slice_1_grad/Reshape" + input: "gradients_1/Slice_1_grad/Reshape_1" + input: "gradients_1/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 + } + } +} +node { + name: "gradients_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_1/Reshape_9_grad/Reshape" + input: "gradients_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/AddN_20" + op: "AddN" + input: "gradients_1/Slice_grad/Pad" + input: "gradients_1/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_1/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_1/AddN_20" + input: "gradients_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_37/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_37/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_37/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_37" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_37/stack" + input: "strided_slice_37/stack_1" + input: "strided_slice_37/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_26/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_26" + op: "Mul" + input: "strided_slice_37" + input: "mul_26/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_27/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_27/shape" + op: "Pack" + input: "Reshape_27/shape/0" + input: "mul_26" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_27" + op: "Reshape" + input: "gradients_1/Reshape_4_grad/Reshape" + input: "Reshape_27/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA_1" + op: "ProdForceSeA" + input: "Reshape_27" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA_1" + op: "ProdVirialSeA" + input: "Reshape_27" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_38/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_38/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_38/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_38" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_38/stack" + input: "strided_slice_38/stack_1" + input: "strided_slice_38/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_27/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_27" + op: "Mul" + input: "mul_27/x" + input: "strided_slice_38" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_28/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_28/shape" + op: "Pack" + input: "Reshape_28/shape/0" + input: "mul_27" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_28" + op: "Reshape" + input: "ProdForceSeA_1" + input: "Reshape_28/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_29/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_29" + op: "Reshape" + input: "ProdVirialSeA_1" + input: "Reshape_29/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_39/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_39/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_39/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_39" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_39/stack" + input: "strided_slice_39/stack_1" + input: "strided_slice_39/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_28/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_28" + op: "Mul" + input: "mul_28/x" + input: "strided_slice_39" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_30/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_30/shape" + op: "Pack" + input: "Reshape_30/shape/0" + input: "mul_28" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_30" + op: "Reshape" + input: "ProdVirialSeA_1:1" + input: "Reshape_30/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Shape" + op: "Shape" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients_2/grad_ys_0" + op: "Fill" + input: "gradients_2/Shape" + input: "gradients_2/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/zeros_like" + op: "ZerosLike" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/zeros_like_1" + op: "ZerosLike" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/zeros_like_2" + op: "ZerosLike" + input: "split:3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/zeros_like_3" + op: "ZerosLike" + input: "split:4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/zeros_like_4" + op: "ZerosLike" + input: "split:5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/zeros_like_5" + op: "ZerosLike" + input: "split:6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/zeros_like_6" + op: "ZerosLike" + input: "split:7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/zeros_like_7" + op: "ZerosLike" + input: "split:8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/split_grad/concat" + op: "ConcatV2" + input: "gradients_2/zeros_like" + input: "gradients_2/zeros_like_1" + input: "gradients_2/grad_ys_0" + input: "gradients_2/zeros_like_2" + input: "gradients_2/zeros_like_3" + input: "gradients_2/zeros_like_4" + input: "gradients_2/zeros_like_5" + input: "gradients_2/zeros_like_6" + input: "gradients_2/zeros_like_7" + input: "split/split_dim" + attr { + key: "N" + value { + i: 9 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_22_grad/Shape" + op: "Shape" + input: "o_polar" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients_2/split_grad/concat" + input: "gradients_2/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/o_polar_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/o_polar_grad/Reshape" + op: "Reshape" + input: "gradients_2/Reshape_22_grad/Reshape" + input: "gradients_2/o_polar_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_21_grad/Shape" + op: "Shape" + input: "add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients_2/o_polar_grad/Reshape" + input: "gradients_2/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_7_grad/Shape" + op: "Shape" + input: "mul_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_7_grad/Shape_1" + op: "Shape" + input: "mul_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/add_7_grad/Shape" + input: "gradients_2/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_7_grad/Sum" + op: "Sum" + input: "gradients_2/Reshape_21_grad/Reshape" + input: "gradients_2/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/add_7_grad/Sum" + input: "gradients_2/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/mul_16_grad/Shape" + op: "Shape" + input: "Reshape_18" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/mul_16_grad/Shape_1" + op: "Shape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/mul_16_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/mul_16_grad/Shape" + input: "gradients_2/mul_16_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/mul_16_grad/Mul" + op: "Mul" + input: "gradients_2/add_7_grad/Reshape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/mul_16_grad/Sum" + op: "Sum" + input: "gradients_2/mul_16_grad/Mul" + input: "gradients_2/mul_16_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/mul_16_grad/Reshape" + op: "Reshape" + input: "gradients_2/mul_16_grad/Sum" + input: "gradients_2/mul_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients_2/mul_16_grad/Reshape" + input: "gradients_2/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_1_grad/MatMul" + op: "BatchMatMulV2" + input: "MatMul" + input: "gradients_2/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/MatMul_1_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_16" + input: "gradients_2/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_1_grad/Shape" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_1_grad/Shape_1" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_1_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/MatMul_1_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/MatMul_1_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/MatMul_1_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/MatMul_1_grad/Shape" + input: "gradients_2/MatMul_1_grad/strided_slice/stack" + input: "gradients_2/MatMul_1_grad/strided_slice/stack_1" + input: "gradients_2/MatMul_1_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/MatMul_1_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/MatMul_1_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/MatMul_1_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/MatMul_1_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/MatMul_1_grad/Shape_1" + input: "gradients_2/MatMul_1_grad/strided_slice_1/stack" + input: "gradients_2/MatMul_1_grad/strided_slice_1/stack_1" + input: "gradients_2/MatMul_1_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/MatMul_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/MatMul_1_grad/strided_slice" + input: "gradients_2/MatMul_1_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_1_grad/Sum" + op: "Sum" + input: "gradients_2/MatMul_1_grad/MatMul" + input: "gradients_2/MatMul_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_1_grad/Reshape" + op: "Reshape" + input: "gradients_2/MatMul_1_grad/Sum" + input: "gradients_2/MatMul_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_1_grad/Sum_1" + op: "Sum" + input: "gradients_2/MatMul_1_grad/MatMul_1" + input: "gradients_2/MatMul_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/MatMul_1_grad/Sum_1" + input: "gradients_2/MatMul_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients_2/MatMul_1_grad/Reshape_1" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "add_6" + input: "gradients_2/MatMul_1_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_grad/Shape" + op: "Shape" + input: "add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/MatMul_grad/Shape" + input: "gradients_2/MatMul_grad/strided_slice/stack" + input: "gradients_2/MatMul_grad/strided_slice/stack_1" + input: "gradients_2/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/MatMul_grad/Shape_1" + input: "gradients_2/MatMul_grad/strided_slice_1/stack" + input: "gradients_2/MatMul_grad/strided_slice_1/stack_1" + input: "gradients_2/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/MatMul_grad/strided_slice" + input: "gradients_2/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/Sum" + op: "Sum" + input: "gradients_2/MatMul_grad/MatMul" + input: "gradients_2/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients_2/MatMul_grad/Sum" + input: "gradients_2/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients_2/MatMul_grad/MatMul_1" + input: "gradients_2/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/MatMul_grad/Sum_1" + input: "gradients_2/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_6_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_6_grad/Shape_1" + op: "Shape" + input: "transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/add_6_grad/Shape" + input: "gradients_2/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_6_grad/Sum" + op: "Sum" + input: "gradients_2/MatMul_grad/Reshape" + input: "gradients_2/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_2/add_6_grad/Sum" + input: "gradients_2/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_6_grad/Sum_1" + op: "Sum" + input: "gradients_2/MatMul_grad/Reshape" + input: "gradients_2/add_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_6_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/add_6_grad/Sum_1" + input: "gradients_2/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN" + op: "AddN" + input: "gradients_2/MatMul_1_grad/Reshape" + input: "gradients_2/MatMul_grad/Reshape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/MatMul_1_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN" + input: "gradients_2/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/transpose_grad/transpose" + op: "Transpose" + input: "gradients_2/add_6_grad/Reshape_1" + input: "gradients_2/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_3_grad/stack" + op: "Pack" + input: "gradients_2/Slice_3_grad/Rank" + input: "gradients_2/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients_2/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/sub" + op: "Sub" + input: "gradients_2/Slice_3_grad/Shape_1" + input: "gradients_2/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_2/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/Slice_3_grad/sub_1" + input: "gradients_2/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_2/Slice_3_grad/Reshape" + input: "gradients_2/Slice_3_grad/Reshape_1" + input: "gradients_2/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 + } + } +} +node { + name: "gradients_2/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_2/Reshape_16_grad/Reshape" + input: "gradients_2/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_1" + op: "AddN" + input: "gradients_2/add_6_grad/Reshape" + input: "gradients_2/transpose_grad/transpose" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/add_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_1" + input: "gradients_2/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_2/Slice_3_grad/Pad" + input: "gradients_2/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/final_layer_type_0/add_grad/Shape" + input: "gradients_2/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/Reshape_17_grad/Reshape" + input: "gradients_2/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/final_layer_type_0/add_grad/Sum" + input: "gradients_2/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients_2/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/concat_1_grad/mod" + input: "gradients_2/concat_1_grad/ShapeN" + input: "gradients_2/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/concat_1_grad/Slice" + op: "Slice" + input: "gradients_2/Reshape_14_grad/Reshape" + input: "gradients_2/concat_1_grad/ConcatOffset" + input: "gradients_2/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_2/Reshape_14_grad/Reshape" + input: "gradients_2/concat_1_grad/ConcatOffset:1" + input: "gradients_2/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/add_5_grad/Shape" + op: "Shape" + input: "add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_5_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/add_5_grad/Shape" + input: "gradients_2/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_5_grad/Sum" + op: "Sum" + input: "gradients_2/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_2/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/add_5_grad/Sum" + input: "gradients_2/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_5_grad/Sum_1" + op: "Sum" + input: "gradients_2/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_2/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/add_5_grad/Sum_1" + input: "gradients_2/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/concat_1_grad/Slice" + input: "gradients_2/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_2/concat_1_grad/Slice_1" + input: "gradients_2/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_2_type_0/mul_grad/Shape" + input: "gradients_2/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_2/add_5_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_2/layer_2_type_0/mul_grad/Mul" + input: "gradients_2/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_2_type_0/mul_grad/Sum" + input: "gradients_2/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients_2/Reshape_8_grad/Reshape" + input: "gradients_2/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients_2/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_2_type_0/mul_grad/Reshape" + input: "gradients_2/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_5_grad/Rank" + input: "gradients_2/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients_2/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_5_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_5_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_0/transpose_grad/transpose" + input: "gradients_2/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_5_grad/Rank" + input: "gradients_2/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients_2/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_5_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_5_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_1/transpose_grad/transpose" + input: "gradients_2/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients_2/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_2_type_0/add_grad/Shape" + input: "gradients_2/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients_2/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_2_type_0/add_grad/Sum" + input: "gradients_2/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/AddN_2" + op: "AddN" + input: "gradients_2/add_5_grad/Reshape" + input: "gradients_2/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/add_4_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_4_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/add_4_grad/Shape" + input: "gradients_2/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_4_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_2" + input: "gradients_2/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/add_4_grad/Sum" + input: "gradients_2/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_2" + input: "gradients_2/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/add_4_grad/Sum_1" + input: "gradients_2/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_1_type_0/mul_grad/Shape" + input: "gradients_2/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_2/add_4_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_2/layer_1_type_0/mul_grad/Mul" + input: "gradients_2/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_1_type_0/mul_grad/Sum" + input: "gradients_2/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_1_type_0/mul_grad/Reshape" + input: "gradients_2/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients_2/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_1_type_0/add_grad/Shape" + input: "gradients_2/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients_2/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_1_type_0/add_grad/Sum" + input: "gradients_2/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/AddN_3" + op: "AddN" + input: "gradients_2/add_4_grad/Reshape" + input: "gradients_2/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_3" + input: "gradients_2/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients_2/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/layer_0_type_0/add_grad/Shape" + input: "gradients_2/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients_2/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_0_type_0/add_grad/Sum" + input: "gradients_2/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients_2/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients_2/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_2_grad/stack" + op: "Pack" + input: "gradients_2/Slice_2_grad/Rank" + input: "gradients_2/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients_2/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/sub" + op: "Sub" + input: "gradients_2/Slice_2_grad/Shape_1" + input: "gradients_2/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_2/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/Slice_2_grad/sub_1" + input: "gradients_2/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_2/Slice_2_grad/Reshape" + input: "gradients_2/Slice_2_grad/Reshape_1" + input: "gradients_2/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 + } + } +} +node { + name: "gradients_2/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_2/Reshape_15_grad/Reshape" + input: "gradients_2/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_2/Slice_2_grad/Pad" + input: "gradients_2/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients_2/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/concat_grad/mod" + input: "gradients_2/concat_grad/ShapeN" + input: "gradients_2/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/concat_grad/Slice" + op: "Slice" + input: "gradients_2/Reshape_13_grad/Reshape" + input: "gradients_2/concat_grad/ConcatOffset" + input: "gradients_2/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/concat_grad/Slice_1" + op: "Slice" + input: "gradients_2/Reshape_13_grad/Reshape" + input: "gradients_2/concat_grad/ConcatOffset:1" + input: "gradients_2/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/concat_grad/Slice" + input: "gradients_2/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_2/concat_grad/Slice_1" + input: "gradients_2/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_2/Reshape_7_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_2/Reshape_11_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients_2/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients_2/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_8_grad/Shape" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients_2/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients_2/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_8_grad/Sum" + input: "gradients_2/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients_2/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients_2/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients_2/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_8_grad/Shape" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients_2/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients_2/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_8_grad/Sum" + input: "gradients_2/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients_2/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_4_grad/Rank" + input: "gradients_2/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients_2/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_4_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_4_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients_2/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_4_grad/Rank" + input: "gradients_2/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients_2/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_4_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_4_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients_2/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_4" + op: "AddN" + input: "gradients_2/filter_type_0/Slice_5_grad/Pad" + input: "gradients_2/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/mul_grad/Shape" + input: "gradients_2/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_2/AddN_4" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/mul_grad/Mul" + input: "gradients_2/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/mul_grad/Sum" + input: "gradients_2/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_5" + op: "AddN" + input: "gradients_2/filter_type_1/Slice_5_grad/Pad" + input: "gradients_2/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/mul_grad/Shape" + input: "gradients_2/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_2/AddN_5" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/mul_grad/Mul" + input: "gradients_2/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/mul_grad/Sum" + input: "gradients_2/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_10_grad/Shape" + input: "gradients_2/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/mul_grad/Reshape" + input: "gradients_2/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_10_grad/Sum" + input: "gradients_2/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/mul_grad/Reshape" + input: "gradients_2/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_10_grad/Sum_1" + input: "gradients_2/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_10_grad/Shape" + input: "gradients_2/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/mul_grad/Reshape" + input: "gradients_2/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_10_grad/Sum" + input: "gradients_2/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/mul_grad/Reshape" + input: "gradients_2/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_10_grad/Sum_1" + input: "gradients_2/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients_2/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients_2/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_3_grad/Shape" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients_2/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients_2/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_3_grad/Sum" + input: "gradients_2/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients_2/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients_2/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients_2/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_7_grad/Shape" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients_2/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients_2/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_7_grad/Sum" + input: "gradients_2/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients_2/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients_2/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients_2/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_3_grad/Shape" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients_2/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients_2/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_3_grad/Sum" + input: "gradients_2/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients_2/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients_2/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients_2/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_7_grad/Shape" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_2/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_2/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients_2/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients_2/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_7_grad/Sum" + input: "gradients_2/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients_2/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_4_grad/Shape" + input: "gradients_2/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_2/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_4_grad/Sum" + input: "gradients_2/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_2/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_4_grad/Sum_1" + input: "gradients_2/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_9_grad/Shape" + input: "gradients_2/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_9_grad/Sum" + input: "gradients_2/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_9_grad/Sum_1" + input: "gradients_2/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_4_grad/Shape" + input: "gradients_2/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_2/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_4_grad/Sum" + input: "gradients_2/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_2/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_4_grad/Sum_1" + input: "gradients_2/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_9_grad/Shape" + input: "gradients_2/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_9_grad/Sum" + input: "gradients_2/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_2/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_2/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_9_grad/Sum_1" + input: "gradients_2/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_1/axis" + input: "gradients_2/filter_type_0/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_2" + input: "filter_type_0/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/filter_type_0/concat_1_grad/mod" + input: "gradients_2/filter_type_0/concat_1_grad/ShapeN" + input: "gradients_2/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_1_grad/Slice" + op: "Slice" + input: "gradients_2/filter_type_0/add_4_grad/Reshape" + input: "gradients_2/filter_type_0/concat_1_grad/ConcatOffset" + input: "gradients_2/filter_type_0/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_2/filter_type_0/add_4_grad/Reshape" + input: "gradients_2/filter_type_0/concat_1_grad/ConcatOffset:1" + input: "gradients_2/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_4_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_3/axis" + input: "gradients_2/filter_type_0/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_7" + input: "filter_type_0/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/filter_type_0/concat_3_grad/mod" + input: "gradients_2/filter_type_0/concat_3_grad/ShapeN" + input: "gradients_2/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_3_grad/Slice" + op: "Slice" + input: "gradients_2/filter_type_0/add_9_grad/Reshape" + input: "gradients_2/filter_type_0/concat_3_grad/ConcatOffset" + input: "gradients_2/filter_type_0/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_2/filter_type_0/add_9_grad/Reshape" + input: "gradients_2/filter_type_0/concat_3_grad/ConcatOffset:1" + input: "gradients_2/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_9_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_1/axis" + input: "gradients_2/filter_type_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_2" + input: "filter_type_1/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/filter_type_1/concat_1_grad/mod" + input: "gradients_2/filter_type_1/concat_1_grad/ShapeN" + input: "gradients_2/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients_2/filter_type_1/add_4_grad/Reshape" + input: "gradients_2/filter_type_1/concat_1_grad/ConcatOffset" + input: "gradients_2/filter_type_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_2/filter_type_1/add_4_grad/Reshape" + input: "gradients_2/filter_type_1/concat_1_grad/ConcatOffset:1" + input: "gradients_2/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_4_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_3/axis" + input: "gradients_2/filter_type_1/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_7" + input: "filter_type_1/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/filter_type_1/concat_3_grad/mod" + input: "gradients_2/filter_type_1/concat_3_grad/ShapeN" + input: "gradients_2/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_3_grad/Slice" + op: "Slice" + input: "gradients_2/filter_type_1/add_9_grad/Reshape" + input: "gradients_2/filter_type_1/concat_3_grad/ConcatOffset" + input: "gradients_2/filter_type_1/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_2/filter_type_1/add_9_grad/Reshape" + input: "gradients_2/filter_type_1/concat_3_grad/ConcatOffset:1" + input: "gradients_2/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_9_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients_2/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients_2/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients_2/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients_2/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_3_grad/Shape" + input: "gradients_2/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_3_grad/Sum" + input: "gradients_2/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_8_grad/Shape" + input: "gradients_2/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_8_grad/Sum" + input: "gradients_2/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_3_grad/Shape" + input: "gradients_2/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_3_grad/Sum" + input: "gradients_2/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_8_grad/Shape" + input: "gradients_2/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_8_grad/Sum" + input: "gradients_2/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/AddN_6" + op: "AddN" + input: "gradients_2/filter_type_0/concat_1_grad/Slice" + input: "gradients_2/filter_type_0/concat_1_grad/Slice_1" + input: "gradients_2/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_2_grad/Shape" + input: "gradients_2/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_6" + input: "gradients_2/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_2_grad/Sum" + input: "gradients_2/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_6" + input: "gradients_2/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_2_grad/Sum_1" + input: "gradients_2/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_7" + op: "AddN" + input: "gradients_2/filter_type_0/concat_3_grad/Slice" + input: "gradients_2/filter_type_0/concat_3_grad/Slice_1" + input: "gradients_2/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_7_grad/Shape" + input: "gradients_2/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_7" + input: "gradients_2/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_7_grad/Sum" + input: "gradients_2/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_7" + input: "gradients_2/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/add_7_grad/Sum_1" + input: "gradients_2/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_8" + op: "AddN" + input: "gradients_2/filter_type_1/concat_1_grad/Slice" + input: "gradients_2/filter_type_1/concat_1_grad/Slice_1" + input: "gradients_2/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_2_grad/Shape" + input: "gradients_2/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_8" + input: "gradients_2/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_2_grad/Sum" + input: "gradients_2/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_8" + input: "gradients_2/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_2_grad/Sum_1" + input: "gradients_2/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_9" + op: "AddN" + input: "gradients_2/filter_type_1/concat_3_grad/Slice" + input: "gradients_2/filter_type_1/concat_3_grad/Slice_1" + input: "gradients_2/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_7_grad/Shape" + input: "gradients_2/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients_2/AddN_9" + input: "gradients_2/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_7_grad/Sum" + input: "gradients_2/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_2/AddN_9" + input: "gradients_2/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/add_7_grad/Sum_1" + input: "gradients_2/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/concat_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat/axis" + input: "gradients_2/filter_type_0/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/filter_type_0/concat_grad/mod" + input: "gradients_2/filter_type_0/concat_grad/ShapeN" + input: "gradients_2/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_grad/Slice" + op: "Slice" + input: "gradients_2/filter_type_0/add_2_grad/Reshape" + input: "gradients_2/filter_type_0/concat_grad/ConcatOffset" + input: "gradients_2/filter_type_0/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/concat_grad/Slice_1" + op: "Slice" + input: "gradients_2/filter_type_0/add_2_grad/Reshape" + input: "gradients_2/filter_type_0/concat_grad/ConcatOffset:1" + input: "gradients_2/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_2_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_2/axis" + input: "gradients_2/filter_type_0/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/filter_type_0/concat_2_grad/mod" + input: "gradients_2/filter_type_0/concat_2_grad/ShapeN" + input: "gradients_2/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/filter_type_0/concat_2_grad/Slice" + op: "Slice" + input: "gradients_2/filter_type_0/add_7_grad/Reshape" + input: "gradients_2/filter_type_0/concat_2_grad/ConcatOffset" + input: "gradients_2/filter_type_0/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_2/filter_type_0/add_7_grad/Reshape" + input: "gradients_2/filter_type_0/concat_2_grad/ConcatOffset:1" + input: "gradients_2/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_7_grad/Reshape_1" + input: "gradients_2/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/concat_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat/axis" + input: "gradients_2/filter_type_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/filter_type_1/concat_grad/mod" + input: "gradients_2/filter_type_1/concat_grad/ShapeN" + input: "gradients_2/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_grad/Slice" + op: "Slice" + input: "gradients_2/filter_type_1/add_2_grad/Reshape" + input: "gradients_2/filter_type_1/concat_grad/ConcatOffset" + input: "gradients_2/filter_type_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients_2/filter_type_1/add_2_grad/Reshape" + input: "gradients_2/filter_type_1/concat_grad/ConcatOffset:1" + input: "gradients_2/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_2_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_2/axis" + input: "gradients_2/filter_type_1/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_2/filter_type_1/concat_2_grad/mod" + input: "gradients_2/filter_type_1/concat_2_grad/ShapeN" + input: "gradients_2/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_2/filter_type_1/concat_2_grad/Slice" + op: "Slice" + input: "gradients_2/filter_type_1/add_7_grad/Reshape" + input: "gradients_2/filter_type_1/concat_2_grad/ConcatOffset" + input: "gradients_2/filter_type_1/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_2/filter_type_1/add_7_grad/Reshape" + input: "gradients_2/filter_type_1/concat_2_grad/ConcatOffset:1" + input: "gradients_2/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_7_grad/Reshape_1" + input: "gradients_2/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients_2/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients_2/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients_2/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients_2/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_1_grad/Shape" + input: "gradients_2/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_1_grad/Sum" + input: "gradients_2/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_6_grad/Shape" + input: "gradients_2/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_6_grad/Sum" + input: "gradients_2/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_1_grad/Shape" + input: "gradients_2/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_1_grad/Sum" + input: "gradients_2/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_6_grad/Shape" + input: "gradients_2/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_6_grad/Sum" + input: "gradients_2/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/AddN_10" + op: "AddN" + input: "gradients_2/filter_type_0/concat_grad/Slice" + input: "gradients_2/filter_type_0/concat_grad/Slice_1" + input: "gradients_2/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_10" + input: "gradients_2/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_11" + op: "AddN" + input: "gradients_2/filter_type_0/concat_2_grad/Slice" + input: "gradients_2/filter_type_0/concat_2_grad/Slice_1" + input: "gradients_2/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_11" + input: "gradients_2/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_12" + op: "AddN" + input: "gradients_2/filter_type_1/concat_grad/Slice" + input: "gradients_2/filter_type_1/concat_grad/Slice_1" + input: "gradients_2/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_12" + input: "gradients_2/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_13" + op: "AddN" + input: "gradients_2/filter_type_1/concat_2_grad/Slice" + input: "gradients_2/filter_type_1/concat_2_grad/Slice_1" + input: "gradients_2/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_13" + input: "gradients_2/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients_2/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients_2/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients_2/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients_2/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_grad/Shape" + input: "gradients_2/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_grad/Sum" + input: "gradients_2/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_0/add_5_grad/Shape" + input: "gradients_2/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients_2/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/add_5_grad/Sum" + input: "gradients_2/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_grad/Shape" + input: "gradients_2/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_grad/Sum" + input: "gradients_2/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_2/filter_type_1/add_5_grad/Shape" + input: "gradients_2/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_2/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients_2/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_2/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/add_5_grad/Sum" + input: "gradients_2/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_2/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_grad/MatMul" + input: "gradients_2/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients_2/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_grad/MatMul" + input: "gradients_2/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients_2/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_1_grad/Rank" + input: "gradients_2/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients_2/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_1_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_1_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_3_grad/Rank" + input: "gradients_2/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients_2/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_3_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_3_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_1_grad/Rank" + input: "gradients_2/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients_2/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_1_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_1_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_3_grad/Rank" + input: "gradients_2/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients_2/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_3_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_3_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_2/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_1_grad/Pad" + input: "gradients_2/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_3_grad/Pad" + input: "gradients_2/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_1_grad/Pad" + input: "gradients_2/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_3_grad/Pad" + input: "gradients_2/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_14" + op: "AddN" + input: "gradients_2/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_grad/Rank" + input: "gradients_2/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients_2/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_grad/Reshape_1" + input: "gradients_2/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients_2/AddN_14" + input: "gradients_2/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_15" + op: "AddN" + input: "gradients_2/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients_2/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_0/Slice_2_grad/Rank" + input: "gradients_2/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients_2/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients_2/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_0/Slice_2_grad/sub_1" + input: "gradients_2/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_0/Slice_2_grad/Reshape" + input: "gradients_2/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients_2/filter_type_0/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 + } + } +} +node { + name: "gradients_2/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_2/AddN_15" + input: "gradients_2/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_16" + op: "AddN" + input: "gradients_2/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_grad/Rank" + input: "gradients_2/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients_2/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_grad/Reshape_1" + input: "gradients_2/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_2/AddN_16" + input: "gradients_2/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_17" + op: "AddN" + input: "gradients_2/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients_2/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_2/filter_type_1/Slice_2_grad/Rank" + input: "gradients_2/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients_2/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients_2/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_2/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/filter_type_1/Slice_2_grad/sub_1" + input: "gradients_2/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_2/filter_type_1/Slice_2_grad/Reshape" + input: "gradients_2/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients_2/filter_type_1/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 + } + } +} +node { + name: "gradients_2/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_2/AddN_17" + input: "gradients_2/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_18" + op: "AddN" + input: "gradients_2/filter_type_0/Slice_grad/Pad" + input: "gradients_2/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_2/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_18" + input: "gradients_2/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_19" + op: "AddN" + input: "gradients_2/filter_type_1/Slice_grad/Pad" + input: "gradients_2/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_2/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_19" + input: "gradients_2/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_grad/stack" + op: "Pack" + input: "gradients_2/Slice_grad/Rank" + input: "gradients_2/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients_2/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/sub" + op: "Sub" + input: "gradients_2/Slice_grad/Shape_1" + input: "gradients_2/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/sub_1" + op: "Sub" + input: "gradients_2/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/Slice_grad/sub_1" + input: "gradients_2/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_2/Slice_grad/Reshape" + input: "gradients_2/Slice_grad/Reshape_1" + input: "gradients_2/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_grad/Pad" + op: "Pad" + input: "gradients_2/Reshape_5_grad/Reshape" + input: "gradients_2/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_2/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_1_grad/stack" + op: "Pack" + input: "gradients_2/Slice_1_grad/Rank" + input: "gradients_2/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients_2/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/sub" + op: "Sub" + input: "gradients_2/Slice_1_grad/Shape_1" + input: "gradients_2/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_2/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_2/Slice_1_grad/sub_1" + input: "gradients_2/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_2/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_2/Slice_1_grad/Reshape" + input: "gradients_2/Slice_1_grad/Reshape_1" + input: "gradients_2/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 + } + } +} +node { + name: "gradients_2/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_2/Reshape_9_grad/Reshape" + input: "gradients_2/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/AddN_20" + op: "AddN" + input: "gradients_2/Slice_grad/Pad" + input: "gradients_2/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_2/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_2/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_2/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_2/AddN_20" + input: "gradients_2/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_40/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_40/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_40/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_40" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_40/stack" + input: "strided_slice_40/stack_1" + input: "strided_slice_40/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_29/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_29" + op: "Mul" + input: "strided_slice_40" + input: "mul_29/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_31/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_31/shape" + op: "Pack" + input: "Reshape_31/shape/0" + input: "mul_29" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_31" + op: "Reshape" + input: "gradients_2/Reshape_4_grad/Reshape" + input: "Reshape_31/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA_2" + op: "ProdForceSeA" + input: "Reshape_31" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA_2" + op: "ProdVirialSeA" + input: "Reshape_31" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_41/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_41/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_41/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_41" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_41/stack" + input: "strided_slice_41/stack_1" + input: "strided_slice_41/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_30/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_30" + op: "Mul" + input: "mul_30/x" + input: "strided_slice_41" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_32/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_32/shape" + op: "Pack" + input: "Reshape_32/shape/0" + input: "mul_30" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_32" + op: "Reshape" + input: "ProdForceSeA_2" + input: "Reshape_32/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_33/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_33" + op: "Reshape" + input: "ProdVirialSeA_2" + input: "Reshape_33/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_42/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_42/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_42/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_42" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_42/stack" + input: "strided_slice_42/stack_1" + input: "strided_slice_42/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_31/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_31" + op: "Mul" + input: "mul_31/x" + input: "strided_slice_42" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_34/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_34/shape" + op: "Pack" + input: "Reshape_34/shape/0" + input: "mul_31" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_34" + op: "Reshape" + input: "ProdVirialSeA_2:1" + input: "Reshape_34/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Shape" + op: "Shape" + input: "split:3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients_3/grad_ys_0" + op: "Fill" + input: "gradients_3/Shape" + input: "gradients_3/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/zeros_like" + op: "ZerosLike" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/zeros_like_1" + op: "ZerosLike" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/zeros_like_2" + op: "ZerosLike" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/zeros_like_3" + op: "ZerosLike" + input: "split:4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/zeros_like_4" + op: "ZerosLike" + input: "split:5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/zeros_like_5" + op: "ZerosLike" + input: "split:6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/zeros_like_6" + op: "ZerosLike" + input: "split:7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/zeros_like_7" + op: "ZerosLike" + input: "split:8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/split_grad/concat" + op: "ConcatV2" + input: "gradients_3/zeros_like" + input: "gradients_3/zeros_like_1" + input: "gradients_3/zeros_like_2" + input: "gradients_3/grad_ys_0" + input: "gradients_3/zeros_like_3" + input: "gradients_3/zeros_like_4" + input: "gradients_3/zeros_like_5" + input: "gradients_3/zeros_like_6" + input: "gradients_3/zeros_like_7" + input: "split/split_dim" + attr { + key: "N" + value { + i: 9 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_22_grad/Shape" + op: "Shape" + input: "o_polar" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients_3/split_grad/concat" + input: "gradients_3/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/o_polar_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/o_polar_grad/Reshape" + op: "Reshape" + input: "gradients_3/Reshape_22_grad/Reshape" + input: "gradients_3/o_polar_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_21_grad/Shape" + op: "Shape" + input: "add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients_3/o_polar_grad/Reshape" + input: "gradients_3/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_7_grad/Shape" + op: "Shape" + input: "mul_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_7_grad/Shape_1" + op: "Shape" + input: "mul_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/add_7_grad/Shape" + input: "gradients_3/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_7_grad/Sum" + op: "Sum" + input: "gradients_3/Reshape_21_grad/Reshape" + input: "gradients_3/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_3/add_7_grad/Sum" + input: "gradients_3/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/mul_16_grad/Shape" + op: "Shape" + input: "Reshape_18" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/mul_16_grad/Shape_1" + op: "Shape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/mul_16_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/mul_16_grad/Shape" + input: "gradients_3/mul_16_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/mul_16_grad/Mul" + op: "Mul" + input: "gradients_3/add_7_grad/Reshape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/mul_16_grad/Sum" + op: "Sum" + input: "gradients_3/mul_16_grad/Mul" + input: "gradients_3/mul_16_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/mul_16_grad/Reshape" + op: "Reshape" + input: "gradients_3/mul_16_grad/Sum" + input: "gradients_3/mul_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients_3/mul_16_grad/Reshape" + input: "gradients_3/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/MatMul_1_grad/MatMul" + op: "BatchMatMulV2" + input: "MatMul" + input: "gradients_3/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_3/MatMul_1_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_16" + input: "gradients_3/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_3/MatMul_1_grad/Shape" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/MatMul_1_grad/Shape_1" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/MatMul_1_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/MatMul_1_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/MatMul_1_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/MatMul_1_grad/strided_slice" + op: "StridedSlice" + input: "gradients_3/MatMul_1_grad/Shape" + input: "gradients_3/MatMul_1_grad/strided_slice/stack" + input: "gradients_3/MatMul_1_grad/strided_slice/stack_1" + input: "gradients_3/MatMul_1_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/MatMul_1_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/MatMul_1_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/MatMul_1_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/MatMul_1_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_3/MatMul_1_grad/Shape_1" + input: "gradients_3/MatMul_1_grad/strided_slice_1/stack" + input: "gradients_3/MatMul_1_grad/strided_slice_1/stack_1" + input: "gradients_3/MatMul_1_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/MatMul_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/MatMul_1_grad/strided_slice" + input: "gradients_3/MatMul_1_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/MatMul_1_grad/Sum" + op: "Sum" + input: "gradients_3/MatMul_1_grad/MatMul" + input: "gradients_3/MatMul_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/MatMul_1_grad/Reshape" + op: "Reshape" + input: "gradients_3/MatMul_1_grad/Sum" + input: "gradients_3/MatMul_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/MatMul_1_grad/Sum_1" + op: "Sum" + input: "gradients_3/MatMul_1_grad/MatMul_1" + input: "gradients_3/MatMul_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/MatMul_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/MatMul_1_grad/Sum_1" + input: "gradients_3/MatMul_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients_3/MatMul_1_grad/Reshape_1" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_3/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "add_6" + input: "gradients_3/MatMul_1_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_3/MatMul_grad/Shape" + op: "Shape" + input: "add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients_3/MatMul_grad/Shape" + input: "gradients_3/MatMul_grad/strided_slice/stack" + input: "gradients_3/MatMul_grad/strided_slice/stack_1" + input: "gradients_3/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_3/MatMul_grad/Shape_1" + input: "gradients_3/MatMul_grad/strided_slice_1/stack" + input: "gradients_3/MatMul_grad/strided_slice_1/stack_1" + input: "gradients_3/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/MatMul_grad/strided_slice" + input: "gradients_3/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/MatMul_grad/Sum" + op: "Sum" + input: "gradients_3/MatMul_grad/MatMul" + input: "gradients_3/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients_3/MatMul_grad/Sum" + input: "gradients_3/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients_3/MatMul_grad/MatMul_1" + input: "gradients_3/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/MatMul_grad/Sum_1" + input: "gradients_3/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_6_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_6_grad/Shape_1" + op: "Shape" + input: "transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/add_6_grad/Shape" + input: "gradients_3/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_6_grad/Sum" + op: "Sum" + input: "gradients_3/MatMul_grad/Reshape" + input: "gradients_3/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_3/add_6_grad/Sum" + input: "gradients_3/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_6_grad/Sum_1" + op: "Sum" + input: "gradients_3/MatMul_grad/Reshape" + input: "gradients_3/add_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/add_6_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/add_6_grad/Sum_1" + input: "gradients_3/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN" + op: "AddN" + input: "gradients_3/MatMul_1_grad/Reshape" + input: "gradients_3/MatMul_grad/Reshape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/MatMul_1_grad/Reshape" + } + } + } +} +node { + name: "gradients_3/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients_3/AddN" + input: "gradients_3/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/transpose_grad/transpose" + op: "Transpose" + input: "gradients_3/add_6_grad/Reshape_1" + input: "gradients_3/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/Slice_3_grad/stack" + op: "Pack" + input: "gradients_3/Slice_3_grad/Rank" + input: "gradients_3/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients_3/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_3_grad/sub" + op: "Sub" + input: "gradients_3/Slice_3_grad/Shape_1" + input: "gradients_3/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_3/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/Slice_3_grad/sub_1" + input: "gradients_3/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_3/Slice_3_grad/Reshape" + input: "gradients_3/Slice_3_grad/Reshape_1" + input: "gradients_3/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 + } + } +} +node { + name: "gradients_3/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_3/Reshape_16_grad/Reshape" + input: "gradients_3/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_1" + op: "AddN" + input: "gradients_3/add_6_grad/Reshape" + input: "gradients_3/transpose_grad/transpose" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/add_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_3/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients_3/AddN_1" + input: "gradients_3/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_3/Slice_3_grad/Pad" + input: "gradients_3/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/final_layer_type_0/add_grad/Shape" + input: "gradients_3/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_3/Reshape_17_grad/Reshape" + input: "gradients_3/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_3/final_layer_type_0/add_grad/Sum" + input: "gradients_3/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_3/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients_3/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_3/concat_1_grad/mod" + input: "gradients_3/concat_1_grad/ShapeN" + input: "gradients_3/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_3/concat_1_grad/Slice" + op: "Slice" + input: "gradients_3/Reshape_14_grad/Reshape" + input: "gradients_3/concat_1_grad/ConcatOffset" + input: "gradients_3/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_3/Reshape_14_grad/Reshape" + input: "gradients_3/concat_1_grad/ConcatOffset:1" + input: "gradients_3/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/add_5_grad/Shape" + op: "Shape" + input: "add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_5_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/add_5_grad/Shape" + input: "gradients_3/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_5_grad/Sum" + op: "Sum" + input: "gradients_3/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_3/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_3/add_5_grad/Sum" + input: "gradients_3/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_5_grad/Sum_1" + op: "Sum" + input: "gradients_3/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_3/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/add_5_grad/Sum_1" + input: "gradients_3/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_3/concat_1_grad/Slice" + input: "gradients_3/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_3/concat_1_grad/Slice_1" + input: "gradients_3/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/layer_2_type_0/mul_grad/Shape" + input: "gradients_3/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_3/add_5_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_3/layer_2_type_0/mul_grad/Mul" + input: "gradients_3/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_3/layer_2_type_0/mul_grad/Sum" + input: "gradients_3/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients_3/Reshape_8_grad/Reshape" + input: "gradients_3/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients_3/Reshape_12_grad/Reshape" + input: "gradients_3/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_3/layer_2_type_0/mul_grad/Reshape" + input: "gradients_3/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients_3/filter_type_0/Slice_5_grad/Rank" + input: "gradients_3/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients_3/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients_3/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients_3/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_3/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_0/Slice_5_grad/sub_1" + input: "gradients_3/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_3/filter_type_0/Slice_5_grad/Reshape" + input: "gradients_3/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients_3/filter_type_0/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 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_3/filter_type_0/transpose_grad/transpose" + input: "gradients_3/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients_3/filter_type_1/Slice_5_grad/Rank" + input: "gradients_3/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients_3/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients_3/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients_3/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_3/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_1/Slice_5_grad/sub_1" + input: "gradients_3/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_3/filter_type_1/Slice_5_grad/Reshape" + input: "gradients_3/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients_3/filter_type_1/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 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_3/filter_type_1/transpose_grad/transpose" + input: "gradients_3/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients_3/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/layer_2_type_0/add_grad/Shape" + input: "gradients_3/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_3/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients_3/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_3/layer_2_type_0/add_grad/Sum" + input: "gradients_3/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_3/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/AddN_2" + op: "AddN" + input: "gradients_3/add_5_grad/Reshape" + input: "gradients_3/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients_3/add_4_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_4_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/add_4_grad/Shape" + input: "gradients_3/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_4_grad/Sum" + op: "Sum" + input: "gradients_3/AddN_2" + input: "gradients_3/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_3/add_4_grad/Sum" + input: "gradients_3/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_3/AddN_2" + input: "gradients_3/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/add_4_grad/Sum_1" + input: "gradients_3/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/layer_1_type_0/mul_grad/Shape" + input: "gradients_3/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_3/add_4_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_3/layer_1_type_0/mul_grad/Mul" + input: "gradients_3/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_3/layer_1_type_0/mul_grad/Sum" + input: "gradients_3/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_3/layer_1_type_0/mul_grad/Reshape" + input: "gradients_3/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients_3/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/layer_1_type_0/add_grad/Shape" + input: "gradients_3/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_3/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients_3/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_3/layer_1_type_0/add_grad/Sum" + input: "gradients_3/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_3/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/AddN_3" + op: "AddN" + input: "gradients_3/add_4_grad/Reshape" + input: "gradients_3/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_3/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_3/AddN_3" + input: "gradients_3/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients_3/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/layer_0_type_0/add_grad/Shape" + input: "gradients_3/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_3/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients_3/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_3/layer_0_type_0/add_grad/Sum" + input: "gradients_3/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_3/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients_3/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients_3/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/Slice_2_grad/stack" + op: "Pack" + input: "gradients_3/Slice_2_grad/Rank" + input: "gradients_3/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients_3/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_2_grad/sub" + op: "Sub" + input: "gradients_3/Slice_2_grad/Shape_1" + input: "gradients_3/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_3/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/Slice_2_grad/sub_1" + input: "gradients_3/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_3/Slice_2_grad/Reshape" + input: "gradients_3/Slice_2_grad/Reshape_1" + input: "gradients_3/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 + } + } +} +node { + name: "gradients_3/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_3/Reshape_15_grad/Reshape" + input: "gradients_3/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_3/Slice_2_grad/Pad" + input: "gradients_3/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients_3/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_3/concat_grad/mod" + input: "gradients_3/concat_grad/ShapeN" + input: "gradients_3/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_3/concat_grad/Slice" + op: "Slice" + input: "gradients_3/Reshape_13_grad/Reshape" + input: "gradients_3/concat_grad/ConcatOffset" + input: "gradients_3/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/concat_grad/Slice_1" + op: "Slice" + input: "gradients_3/Reshape_13_grad/Reshape" + input: "gradients_3/concat_grad/ConcatOffset:1" + input: "gradients_3/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_3/concat_grad/Slice" + input: "gradients_3/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_3/concat_grad/Slice_1" + input: "gradients_3/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_3/Reshape_7_grad/Reshape" + input: "gradients_3/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_3/Reshape_11_grad/Reshape" + input: "gradients_3/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients_3/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients_3/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_3/filter_type_0/MatMul_8_grad/Shape" + input: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_3/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients_3/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients_3/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/MatMul_8_grad/Sum" + input: "gradients_3/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_3/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients_3/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients_3/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients_3/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients_3/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_3/filter_type_1/MatMul_8_grad/Shape" + input: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_3/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients_3/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients_3/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/MatMul_8_grad/Sum" + input: "gradients_3/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_3/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients_3/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients_3/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients_3/filter_type_0/Slice_4_grad/Rank" + input: "gradients_3/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients_3/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients_3/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients_3/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_3/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_0/Slice_4_grad/sub_1" + input: "gradients_3/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_3/filter_type_0/Slice_4_grad/Reshape" + input: "gradients_3/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients_3/filter_type_0/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 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_3/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients_3/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients_3/filter_type_1/Slice_4_grad/Rank" + input: "gradients_3/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients_3/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients_3/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients_3/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_3/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_1/Slice_4_grad/sub_1" + input: "gradients_3/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_3/filter_type_1/Slice_4_grad/Reshape" + input: "gradients_3/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients_3/filter_type_1/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 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_3/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients_3/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_4" + op: "AddN" + input: "gradients_3/filter_type_0/Slice_5_grad/Pad" + input: "gradients_3/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients_3/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_3/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/mul_grad/Shape" + input: "gradients_3/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_3/AddN_4" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_0/mul_grad/Mul" + input: "gradients_3/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/mul_grad/Sum" + input: "gradients_3/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_5" + op: "AddN" + input: "gradients_3/filter_type_1/Slice_5_grad/Pad" + input: "gradients_3/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients_3/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_3/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/mul_grad/Shape" + input: "gradients_3/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_3/AddN_5" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_1/mul_grad/Mul" + input: "gradients_3/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/mul_grad/Sum" + input: "gradients_3/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/add_10_grad/Shape" + input: "gradients_3/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_0/mul_grad/Reshape" + input: "gradients_3/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_10_grad/Sum" + input: "gradients_3/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_3/filter_type_0/mul_grad/Reshape" + input: "gradients_3/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_0/add_10_grad/Sum_1" + input: "gradients_3/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/add_10_grad/Shape" + input: "gradients_3/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_1/mul_grad/Reshape" + input: "gradients_3/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_10_grad/Sum" + input: "gradients_3/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_3/filter_type_1/mul_grad/Reshape" + input: "gradients_3/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_1/add_10_grad/Sum_1" + input: "gradients_3/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients_3/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients_3/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_3/filter_type_0/MatMul_3_grad/Shape" + input: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_3/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients_3/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients_3/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/MatMul_3_grad/Sum" + input: "gradients_3/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_3/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients_3/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients_3/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients_3/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients_3/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_3/filter_type_0/MatMul_7_grad/Shape" + input: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_3/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients_3/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients_3/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/MatMul_7_grad/Sum" + input: "gradients_3/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_3/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients_3/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients_3/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients_3/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients_3/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_3/filter_type_1/MatMul_3_grad/Shape" + input: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_3/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients_3/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients_3/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/MatMul_3_grad/Sum" + input: "gradients_3/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_3/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients_3/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients_3/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients_3/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients_3/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_3/filter_type_1/MatMul_7_grad/Shape" + input: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_3/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_3/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients_3/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients_3/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/MatMul_7_grad/Sum" + input: "gradients_3/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_3/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients_3/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients_3/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients_3/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients_3/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients_3/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients_3/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients_3/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients_3/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients_3/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients_3/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/add_4_grad/Shape" + input: "gradients_3/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_3/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_4_grad/Sum" + input: "gradients_3/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_3/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_3/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_0/add_4_grad/Sum_1" + input: "gradients_3/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/add_9_grad/Shape" + input: "gradients_3/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_3/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_9_grad/Sum" + input: "gradients_3/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_3/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_3/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_0/add_9_grad/Sum_1" + input: "gradients_3/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/add_4_grad/Shape" + input: "gradients_3/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_3/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_4_grad/Sum" + input: "gradients_3/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_3/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_3/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_1/add_4_grad/Sum_1" + input: "gradients_3/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/add_9_grad/Shape" + input: "gradients_3/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_3/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_9_grad/Sum" + input: "gradients_3/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_3/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_3/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_1/add_9_grad/Sum_1" + input: "gradients_3/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_0/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_1/axis" + input: "gradients_3/filter_type_0/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_2" + input: "filter_type_0/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_3/filter_type_0/concat_1_grad/mod" + input: "gradients_3/filter_type_0/concat_1_grad/ShapeN" + input: "gradients_3/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_1_grad/Slice" + op: "Slice" + input: "gradients_3/filter_type_0/add_4_grad/Reshape" + input: "gradients_3/filter_type_0/concat_1_grad/ConcatOffset" + input: "gradients_3/filter_type_0/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_3/filter_type_0/add_4_grad/Reshape" + input: "gradients_3/filter_type_0/concat_1_grad/ConcatOffset:1" + input: "gradients_3/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_4_grad/Reshape_1" + input: "gradients_3/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_0/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_3/axis" + input: "gradients_3/filter_type_0/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_7" + input: "filter_type_0/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_3/filter_type_0/concat_3_grad/mod" + input: "gradients_3/filter_type_0/concat_3_grad/ShapeN" + input: "gradients_3/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_3_grad/Slice" + op: "Slice" + input: "gradients_3/filter_type_0/add_9_grad/Reshape" + input: "gradients_3/filter_type_0/concat_3_grad/ConcatOffset" + input: "gradients_3/filter_type_0/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_3/filter_type_0/add_9_grad/Reshape" + input: "gradients_3/filter_type_0/concat_3_grad/ConcatOffset:1" + input: "gradients_3/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_9_grad/Reshape_1" + input: "gradients_3/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_1/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_1/axis" + input: "gradients_3/filter_type_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_2" + input: "filter_type_1/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_3/filter_type_1/concat_1_grad/mod" + input: "gradients_3/filter_type_1/concat_1_grad/ShapeN" + input: "gradients_3/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients_3/filter_type_1/add_4_grad/Reshape" + input: "gradients_3/filter_type_1/concat_1_grad/ConcatOffset" + input: "gradients_3/filter_type_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_3/filter_type_1/add_4_grad/Reshape" + input: "gradients_3/filter_type_1/concat_1_grad/ConcatOffset:1" + input: "gradients_3/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_4_grad/Reshape_1" + input: "gradients_3/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_1/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_3/axis" + input: "gradients_3/filter_type_1/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_7" + input: "filter_type_1/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_3/filter_type_1/concat_3_grad/mod" + input: "gradients_3/filter_type_1/concat_3_grad/ShapeN" + input: "gradients_3/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_3_grad/Slice" + op: "Slice" + input: "gradients_3/filter_type_1/add_9_grad/Reshape" + input: "gradients_3/filter_type_1/concat_3_grad/ConcatOffset" + input: "gradients_3/filter_type_1/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_3/filter_type_1/add_9_grad/Reshape" + input: "gradients_3/filter_type_1/concat_3_grad/ConcatOffset:1" + input: "gradients_3/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_9_grad/Reshape_1" + input: "gradients_3/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients_3/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients_3/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients_3/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients_3/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/add_3_grad/Shape" + input: "gradients_3/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients_3/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_3_grad/Sum" + input: "gradients_3/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/add_8_grad/Shape" + input: "gradients_3/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients_3/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_8_grad/Sum" + input: "gradients_3/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/add_3_grad/Shape" + input: "gradients_3/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients_3/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_3_grad/Sum" + input: "gradients_3/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/add_8_grad/Shape" + input: "gradients_3/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients_3/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_8_grad/Sum" + input: "gradients_3/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_3/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_3/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_3/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_3/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/AddN_6" + op: "AddN" + input: "gradients_3/filter_type_0/concat_1_grad/Slice" + input: "gradients_3/filter_type_0/concat_1_grad/Slice_1" + input: "gradients_3/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_0/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_3/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/add_2_grad/Shape" + input: "gradients_3/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients_3/AddN_6" + input: "gradients_3/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_2_grad/Sum" + input: "gradients_3/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_3/AddN_6" + input: "gradients_3/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_0/add_2_grad/Sum_1" + input: "gradients_3/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_7" + op: "AddN" + input: "gradients_3/filter_type_0/concat_3_grad/Slice" + input: "gradients_3/filter_type_0/concat_3_grad/Slice_1" + input: "gradients_3/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_0/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_3/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/add_7_grad/Shape" + input: "gradients_3/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients_3/AddN_7" + input: "gradients_3/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_7_grad/Sum" + input: "gradients_3/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_3/AddN_7" + input: "gradients_3/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_0/add_7_grad/Sum_1" + input: "gradients_3/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_8" + op: "AddN" + input: "gradients_3/filter_type_1/concat_1_grad/Slice" + input: "gradients_3/filter_type_1/concat_1_grad/Slice_1" + input: "gradients_3/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_1/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_3/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/add_2_grad/Shape" + input: "gradients_3/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients_3/AddN_8" + input: "gradients_3/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_2_grad/Sum" + input: "gradients_3/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_3/AddN_8" + input: "gradients_3/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_1/add_2_grad/Sum_1" + input: "gradients_3/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_9" + op: "AddN" + input: "gradients_3/filter_type_1/concat_3_grad/Slice" + input: "gradients_3/filter_type_1/concat_3_grad/Slice_1" + input: "gradients_3/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_1/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_3/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/add_7_grad/Shape" + input: "gradients_3/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients_3/AddN_9" + input: "gradients_3/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_7_grad/Sum" + input: "gradients_3/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_3/AddN_9" + input: "gradients_3/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_1/add_7_grad/Sum_1" + input: "gradients_3/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_0/concat_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat/axis" + input: "gradients_3/filter_type_0/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_3/filter_type_0/concat_grad/mod" + input: "gradients_3/filter_type_0/concat_grad/ShapeN" + input: "gradients_3/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_grad/Slice" + op: "Slice" + input: "gradients_3/filter_type_0/add_2_grad/Reshape" + input: "gradients_3/filter_type_0/concat_grad/ConcatOffset" + input: "gradients_3/filter_type_0/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/concat_grad/Slice_1" + op: "Slice" + input: "gradients_3/filter_type_0/add_2_grad/Reshape" + input: "gradients_3/filter_type_0/concat_grad/ConcatOffset:1" + input: "gradients_3/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_2_grad/Reshape_1" + input: "gradients_3/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_0/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_2/axis" + input: "gradients_3/filter_type_0/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_3/filter_type_0/concat_2_grad/mod" + input: "gradients_3/filter_type_0/concat_2_grad/ShapeN" + input: "gradients_3/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_3/filter_type_0/concat_2_grad/Slice" + op: "Slice" + input: "gradients_3/filter_type_0/add_7_grad/Reshape" + input: "gradients_3/filter_type_0/concat_2_grad/ConcatOffset" + input: "gradients_3/filter_type_0/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_3/filter_type_0/add_7_grad/Reshape" + input: "gradients_3/filter_type_0/concat_2_grad/ConcatOffset:1" + input: "gradients_3/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_7_grad/Reshape_1" + input: "gradients_3/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_1/concat_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat/axis" + input: "gradients_3/filter_type_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_3/filter_type_1/concat_grad/mod" + input: "gradients_3/filter_type_1/concat_grad/ShapeN" + input: "gradients_3/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_grad/Slice" + op: "Slice" + input: "gradients_3/filter_type_1/add_2_grad/Reshape" + input: "gradients_3/filter_type_1/concat_grad/ConcatOffset" + input: "gradients_3/filter_type_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients_3/filter_type_1/add_2_grad/Reshape" + input: "gradients_3/filter_type_1/concat_grad/ConcatOffset:1" + input: "gradients_3/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_2_grad/Reshape_1" + input: "gradients_3/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_1/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_2/axis" + input: "gradients_3/filter_type_1/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_3/filter_type_1/concat_2_grad/mod" + input: "gradients_3/filter_type_1/concat_2_grad/ShapeN" + input: "gradients_3/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_3/filter_type_1/concat_2_grad/Slice" + op: "Slice" + input: "gradients_3/filter_type_1/add_7_grad/Reshape" + input: "gradients_3/filter_type_1/concat_2_grad/ConcatOffset" + input: "gradients_3/filter_type_1/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_3/filter_type_1/add_7_grad/Reshape" + input: "gradients_3/filter_type_1/concat_2_grad/ConcatOffset:1" + input: "gradients_3/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_7_grad/Reshape_1" + input: "gradients_3/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients_3/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients_3/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients_3/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients_3/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/add_1_grad/Shape" + input: "gradients_3/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients_3/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_1_grad/Sum" + input: "gradients_3/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/add_6_grad/Shape" + input: "gradients_3/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients_3/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_6_grad/Sum" + input: "gradients_3/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/add_1_grad/Shape" + input: "gradients_3/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients_3/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_1_grad/Sum" + input: "gradients_3/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/add_6_grad/Shape" + input: "gradients_3/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients_3/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_6_grad/Sum" + input: "gradients_3/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_3/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_3/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_3/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_3/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/AddN_10" + op: "AddN" + input: "gradients_3/filter_type_0/concat_grad/Slice" + input: "gradients_3/filter_type_0/concat_grad/Slice_1" + input: "gradients_3/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_0/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_3/AddN_10" + input: "gradients_3/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_11" + op: "AddN" + input: "gradients_3/filter_type_0/concat_2_grad/Slice" + input: "gradients_3/filter_type_0/concat_2_grad/Slice_1" + input: "gradients_3/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_0/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_3/AddN_11" + input: "gradients_3/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_12" + op: "AddN" + input: "gradients_3/filter_type_1/concat_grad/Slice" + input: "gradients_3/filter_type_1/concat_grad/Slice_1" + input: "gradients_3/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_1/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_3/AddN_12" + input: "gradients_3/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_13" + op: "AddN" + input: "gradients_3/filter_type_1/concat_2_grad/Slice" + input: "gradients_3/filter_type_1/concat_2_grad/Slice_1" + input: "gradients_3/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_1/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_3/AddN_13" + input: "gradients_3/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients_3/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients_3/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients_3/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients_3/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_3/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/add_grad/Shape" + input: "gradients_3/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients_3/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_grad/Sum" + input: "gradients_3/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_0/add_5_grad/Shape" + input: "gradients_3/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients_3/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/add_5_grad/Sum" + input: "gradients_3/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/add_grad/Shape" + input: "gradients_3/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients_3/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_grad/Sum" + input: "gradients_3/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_3/filter_type_1/add_5_grad/Shape" + input: "gradients_3/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_3/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients_3/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_3/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/add_5_grad/Sum" + input: "gradients_3/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_3/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_3/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_3/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_3/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/MatMul_grad/MatMul" + input: "gradients_3/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients_3/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/MatMul_grad/MatMul" + input: "gradients_3/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients_3/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients_3/filter_type_0/Slice_1_grad/Rank" + input: "gradients_3/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients_3/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients_3/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients_3/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_3/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_0/Slice_1_grad/sub_1" + input: "gradients_3/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_3/filter_type_0/Slice_1_grad/Reshape" + input: "gradients_3/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients_3/filter_type_0/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 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_3/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients_3/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients_3/filter_type_0/Slice_3_grad/Rank" + input: "gradients_3/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients_3/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients_3/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients_3/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_3/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_0/Slice_3_grad/sub_1" + input: "gradients_3/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_3/filter_type_0/Slice_3_grad/Reshape" + input: "gradients_3/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients_3/filter_type_0/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 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_3/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients_3/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_3/filter_type_1/Slice_1_grad/Rank" + input: "gradients_3/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients_3/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_3/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients_3/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_3/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_1/Slice_1_grad/sub_1" + input: "gradients_3/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_3/filter_type_1/Slice_1_grad/Reshape" + input: "gradients_3/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients_3/filter_type_1/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 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_3/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients_3/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_3/filter_type_1/Slice_3_grad/Rank" + input: "gradients_3/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients_3/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_3/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients_3/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_3/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_1/Slice_3_grad/sub_1" + input: "gradients_3/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_3/filter_type_1/Slice_3_grad/Reshape" + input: "gradients_3/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients_3/filter_type_1/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 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_3/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients_3/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/Slice_1_grad/Pad" + input: "gradients_3/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_0/Slice_3_grad/Pad" + input: "gradients_3/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/Slice_1_grad/Pad" + input: "gradients_3/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_3/filter_type_1/Slice_3_grad/Pad" + input: "gradients_3/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_14" + op: "AddN" + input: "gradients_3/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients_3/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients_3/filter_type_0/Slice_grad/Rank" + input: "gradients_3/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients_3/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients_3/filter_type_0/Slice_grad/Shape_1" + input: "gradients_3/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients_3/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_0/Slice_grad/sub_1" + input: "gradients_3/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_3/filter_type_0/Slice_grad/Reshape" + input: "gradients_3/filter_type_0/Slice_grad/Reshape_1" + input: "gradients_3/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients_3/AddN_14" + input: "gradients_3/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_15" + op: "AddN" + input: "gradients_3/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients_3/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients_3/filter_type_0/Slice_2_grad/Rank" + input: "gradients_3/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients_3/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients_3/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients_3/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_3/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_0/Slice_2_grad/sub_1" + input: "gradients_3/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_3/filter_type_0/Slice_2_grad/Reshape" + input: "gradients_3/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients_3/filter_type_0/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 + } + } +} +node { + name: "gradients_3/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_3/AddN_15" + input: "gradients_3/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_16" + op: "AddN" + input: "gradients_3/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients_3/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients_3/filter_type_1/Slice_grad/Rank" + input: "gradients_3/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients_3/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients_3/filter_type_1/Slice_grad/Shape_1" + input: "gradients_3/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_3/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_1/Slice_grad/sub_1" + input: "gradients_3/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_3/filter_type_1/Slice_grad/Reshape" + input: "gradients_3/filter_type_1/Slice_grad/Reshape_1" + input: "gradients_3/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_3/AddN_16" + input: "gradients_3/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_17" + op: "AddN" + input: "gradients_3/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients_3/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_3/filter_type_1/Slice_2_grad/Rank" + input: "gradients_3/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients_3/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_3/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients_3/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_3/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/filter_type_1/Slice_2_grad/sub_1" + input: "gradients_3/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_3/filter_type_1/Slice_2_grad/Reshape" + input: "gradients_3/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients_3/filter_type_1/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 + } + } +} +node { + name: "gradients_3/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_3/AddN_17" + input: "gradients_3/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_18" + op: "AddN" + input: "gradients_3/filter_type_0/Slice_grad/Pad" + input: "gradients_3/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_3/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_3/AddN_18" + input: "gradients_3/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_19" + op: "AddN" + input: "gradients_3/filter_type_1/Slice_grad/Pad" + input: "gradients_3/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_3/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_3/AddN_19" + input: "gradients_3/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/Slice_grad/stack" + op: "Pack" + input: "gradients_3/Slice_grad/Rank" + input: "gradients_3/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients_3/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_grad/sub" + op: "Sub" + input: "gradients_3/Slice_grad/Shape_1" + input: "gradients_3/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_grad/sub_1" + op: "Sub" + input: "gradients_3/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/Slice_grad/sub_1" + input: "gradients_3/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_3/Slice_grad/Reshape" + input: "gradients_3/Slice_grad/Reshape_1" + input: "gradients_3/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_grad/Pad" + op: "Pad" + input: "gradients_3/Reshape_5_grad/Reshape" + input: "gradients_3/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_3/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/Slice_1_grad/stack" + op: "Pack" + input: "gradients_3/Slice_1_grad/Rank" + input: "gradients_3/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_3/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients_3/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_1_grad/sub" + op: "Sub" + input: "gradients_3/Slice_1_grad/Shape_1" + input: "gradients_3/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_3/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_3/Slice_1_grad/sub_1" + input: "gradients_3/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_3/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_3/Slice_1_grad/Reshape" + input: "gradients_3/Slice_1_grad/Reshape_1" + input: "gradients_3/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 + } + } +} +node { + name: "gradients_3/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_3/Reshape_9_grad/Reshape" + input: "gradients_3/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/AddN_20" + op: "AddN" + input: "gradients_3/Slice_grad/Pad" + input: "gradients_3/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_3/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_3/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_3/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_3/AddN_20" + input: "gradients_3/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_43/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_43/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_43/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_43" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_43/stack" + input: "strided_slice_43/stack_1" + input: "strided_slice_43/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_32/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_32" + op: "Mul" + input: "strided_slice_43" + input: "mul_32/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_35/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_35/shape" + op: "Pack" + input: "Reshape_35/shape/0" + input: "mul_32" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_35" + op: "Reshape" + input: "gradients_3/Reshape_4_grad/Reshape" + input: "Reshape_35/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA_3" + op: "ProdForceSeA" + input: "Reshape_35" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA_3" + op: "ProdVirialSeA" + input: "Reshape_35" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_44/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_44/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_44/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_44" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_44/stack" + input: "strided_slice_44/stack_1" + input: "strided_slice_44/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_33/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_33" + op: "Mul" + input: "mul_33/x" + input: "strided_slice_44" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_36/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_36/shape" + op: "Pack" + input: "Reshape_36/shape/0" + input: "mul_33" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_36" + op: "Reshape" + input: "ProdForceSeA_3" + input: "Reshape_36/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_37/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_37" + op: "Reshape" + input: "ProdVirialSeA_3" + input: "Reshape_37/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_45/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_45/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_45/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_45" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_45/stack" + input: "strided_slice_45/stack_1" + input: "strided_slice_45/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_34/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_34" + op: "Mul" + input: "mul_34/x" + input: "strided_slice_45" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_38/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_38/shape" + op: "Pack" + input: "Reshape_38/shape/0" + input: "mul_34" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_38" + op: "Reshape" + input: "ProdVirialSeA_3:1" + input: "Reshape_38/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Shape" + op: "Shape" + input: "split:4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients_4/grad_ys_0" + op: "Fill" + input: "gradients_4/Shape" + input: "gradients_4/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/zeros_like" + op: "ZerosLike" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/zeros_like_1" + op: "ZerosLike" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/zeros_like_2" + op: "ZerosLike" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/zeros_like_3" + op: "ZerosLike" + input: "split:3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/zeros_like_4" + op: "ZerosLike" + input: "split:5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/zeros_like_5" + op: "ZerosLike" + input: "split:6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/zeros_like_6" + op: "ZerosLike" + input: "split:7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/zeros_like_7" + op: "ZerosLike" + input: "split:8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/split_grad/concat" + op: "ConcatV2" + input: "gradients_4/zeros_like" + input: "gradients_4/zeros_like_1" + input: "gradients_4/zeros_like_2" + input: "gradients_4/zeros_like_3" + input: "gradients_4/grad_ys_0" + input: "gradients_4/zeros_like_4" + input: "gradients_4/zeros_like_5" + input: "gradients_4/zeros_like_6" + input: "gradients_4/zeros_like_7" + input: "split/split_dim" + attr { + key: "N" + value { + i: 9 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_22_grad/Shape" + op: "Shape" + input: "o_polar" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients_4/split_grad/concat" + input: "gradients_4/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/o_polar_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/o_polar_grad/Reshape" + op: "Reshape" + input: "gradients_4/Reshape_22_grad/Reshape" + input: "gradients_4/o_polar_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_21_grad/Shape" + op: "Shape" + input: "add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients_4/o_polar_grad/Reshape" + input: "gradients_4/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_7_grad/Shape" + op: "Shape" + input: "mul_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_7_grad/Shape_1" + op: "Shape" + input: "mul_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/add_7_grad/Shape" + input: "gradients_4/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_7_grad/Sum" + op: "Sum" + input: "gradients_4/Reshape_21_grad/Reshape" + input: "gradients_4/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_4/add_7_grad/Sum" + input: "gradients_4/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/mul_16_grad/Shape" + op: "Shape" + input: "Reshape_18" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/mul_16_grad/Shape_1" + op: "Shape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/mul_16_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/mul_16_grad/Shape" + input: "gradients_4/mul_16_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/mul_16_grad/Mul" + op: "Mul" + input: "gradients_4/add_7_grad/Reshape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/mul_16_grad/Sum" + op: "Sum" + input: "gradients_4/mul_16_grad/Mul" + input: "gradients_4/mul_16_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/mul_16_grad/Reshape" + op: "Reshape" + input: "gradients_4/mul_16_grad/Sum" + input: "gradients_4/mul_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients_4/mul_16_grad/Reshape" + input: "gradients_4/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/MatMul_1_grad/MatMul" + op: "BatchMatMulV2" + input: "MatMul" + input: "gradients_4/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_4/MatMul_1_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_16" + input: "gradients_4/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_4/MatMul_1_grad/Shape" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/MatMul_1_grad/Shape_1" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/MatMul_1_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/MatMul_1_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/MatMul_1_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/MatMul_1_grad/strided_slice" + op: "StridedSlice" + input: "gradients_4/MatMul_1_grad/Shape" + input: "gradients_4/MatMul_1_grad/strided_slice/stack" + input: "gradients_4/MatMul_1_grad/strided_slice/stack_1" + input: "gradients_4/MatMul_1_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/MatMul_1_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/MatMul_1_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/MatMul_1_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/MatMul_1_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_4/MatMul_1_grad/Shape_1" + input: "gradients_4/MatMul_1_grad/strided_slice_1/stack" + input: "gradients_4/MatMul_1_grad/strided_slice_1/stack_1" + input: "gradients_4/MatMul_1_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/MatMul_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/MatMul_1_grad/strided_slice" + input: "gradients_4/MatMul_1_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/MatMul_1_grad/Sum" + op: "Sum" + input: "gradients_4/MatMul_1_grad/MatMul" + input: "gradients_4/MatMul_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/MatMul_1_grad/Reshape" + op: "Reshape" + input: "gradients_4/MatMul_1_grad/Sum" + input: "gradients_4/MatMul_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/MatMul_1_grad/Sum_1" + op: "Sum" + input: "gradients_4/MatMul_1_grad/MatMul_1" + input: "gradients_4/MatMul_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/MatMul_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/MatMul_1_grad/Sum_1" + input: "gradients_4/MatMul_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients_4/MatMul_1_grad/Reshape_1" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_4/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "add_6" + input: "gradients_4/MatMul_1_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_4/MatMul_grad/Shape" + op: "Shape" + input: "add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients_4/MatMul_grad/Shape" + input: "gradients_4/MatMul_grad/strided_slice/stack" + input: "gradients_4/MatMul_grad/strided_slice/stack_1" + input: "gradients_4/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_4/MatMul_grad/Shape_1" + input: "gradients_4/MatMul_grad/strided_slice_1/stack" + input: "gradients_4/MatMul_grad/strided_slice_1/stack_1" + input: "gradients_4/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/MatMul_grad/strided_slice" + input: "gradients_4/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/MatMul_grad/Sum" + op: "Sum" + input: "gradients_4/MatMul_grad/MatMul" + input: "gradients_4/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients_4/MatMul_grad/Sum" + input: "gradients_4/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients_4/MatMul_grad/MatMul_1" + input: "gradients_4/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/MatMul_grad/Sum_1" + input: "gradients_4/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_6_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_6_grad/Shape_1" + op: "Shape" + input: "transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/add_6_grad/Shape" + input: "gradients_4/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_6_grad/Sum" + op: "Sum" + input: "gradients_4/MatMul_grad/Reshape" + input: "gradients_4/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_4/add_6_grad/Sum" + input: "gradients_4/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_6_grad/Sum_1" + op: "Sum" + input: "gradients_4/MatMul_grad/Reshape" + input: "gradients_4/add_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/add_6_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/add_6_grad/Sum_1" + input: "gradients_4/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN" + op: "AddN" + input: "gradients_4/MatMul_1_grad/Reshape" + input: "gradients_4/MatMul_grad/Reshape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/MatMul_1_grad/Reshape" + } + } + } +} +node { + name: "gradients_4/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients_4/AddN" + input: "gradients_4/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/transpose_grad/transpose" + op: "Transpose" + input: "gradients_4/add_6_grad/Reshape_1" + input: "gradients_4/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/Slice_3_grad/stack" + op: "Pack" + input: "gradients_4/Slice_3_grad/Rank" + input: "gradients_4/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients_4/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_3_grad/sub" + op: "Sub" + input: "gradients_4/Slice_3_grad/Shape_1" + input: "gradients_4/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_4/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/Slice_3_grad/sub_1" + input: "gradients_4/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_4/Slice_3_grad/Reshape" + input: "gradients_4/Slice_3_grad/Reshape_1" + input: "gradients_4/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 + } + } +} +node { + name: "gradients_4/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_4/Reshape_16_grad/Reshape" + input: "gradients_4/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_1" + op: "AddN" + input: "gradients_4/add_6_grad/Reshape" + input: "gradients_4/transpose_grad/transpose" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/add_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_4/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients_4/AddN_1" + input: "gradients_4/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_4/Slice_3_grad/Pad" + input: "gradients_4/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/final_layer_type_0/add_grad/Shape" + input: "gradients_4/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_4/Reshape_17_grad/Reshape" + input: "gradients_4/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_4/final_layer_type_0/add_grad/Sum" + input: "gradients_4/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_4/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients_4/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_4/concat_1_grad/mod" + input: "gradients_4/concat_1_grad/ShapeN" + input: "gradients_4/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_4/concat_1_grad/Slice" + op: "Slice" + input: "gradients_4/Reshape_14_grad/Reshape" + input: "gradients_4/concat_1_grad/ConcatOffset" + input: "gradients_4/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_4/Reshape_14_grad/Reshape" + input: "gradients_4/concat_1_grad/ConcatOffset:1" + input: "gradients_4/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/add_5_grad/Shape" + op: "Shape" + input: "add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_5_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/add_5_grad/Shape" + input: "gradients_4/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_5_grad/Sum" + op: "Sum" + input: "gradients_4/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_4/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_4/add_5_grad/Sum" + input: "gradients_4/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_5_grad/Sum_1" + op: "Sum" + input: "gradients_4/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_4/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/add_5_grad/Sum_1" + input: "gradients_4/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_4/concat_1_grad/Slice" + input: "gradients_4/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_4/concat_1_grad/Slice_1" + input: "gradients_4/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/layer_2_type_0/mul_grad/Shape" + input: "gradients_4/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_4/add_5_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_4/layer_2_type_0/mul_grad/Mul" + input: "gradients_4/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_4/layer_2_type_0/mul_grad/Sum" + input: "gradients_4/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients_4/Reshape_8_grad/Reshape" + input: "gradients_4/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients_4/Reshape_12_grad/Reshape" + input: "gradients_4/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_4/layer_2_type_0/mul_grad/Reshape" + input: "gradients_4/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients_4/filter_type_0/Slice_5_grad/Rank" + input: "gradients_4/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients_4/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients_4/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients_4/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_4/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_0/Slice_5_grad/sub_1" + input: "gradients_4/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_4/filter_type_0/Slice_5_grad/Reshape" + input: "gradients_4/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients_4/filter_type_0/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 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_4/filter_type_0/transpose_grad/transpose" + input: "gradients_4/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients_4/filter_type_1/Slice_5_grad/Rank" + input: "gradients_4/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients_4/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients_4/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients_4/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_4/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_1/Slice_5_grad/sub_1" + input: "gradients_4/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_4/filter_type_1/Slice_5_grad/Reshape" + input: "gradients_4/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients_4/filter_type_1/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 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_4/filter_type_1/transpose_grad/transpose" + input: "gradients_4/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients_4/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/layer_2_type_0/add_grad/Shape" + input: "gradients_4/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_4/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients_4/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_4/layer_2_type_0/add_grad/Sum" + input: "gradients_4/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_4/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/AddN_2" + op: "AddN" + input: "gradients_4/add_5_grad/Reshape" + input: "gradients_4/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients_4/add_4_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_4_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/add_4_grad/Shape" + input: "gradients_4/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_4_grad/Sum" + op: "Sum" + input: "gradients_4/AddN_2" + input: "gradients_4/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_4/add_4_grad/Sum" + input: "gradients_4/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_4/AddN_2" + input: "gradients_4/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/add_4_grad/Sum_1" + input: "gradients_4/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/layer_1_type_0/mul_grad/Shape" + input: "gradients_4/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_4/add_4_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_4/layer_1_type_0/mul_grad/Mul" + input: "gradients_4/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_4/layer_1_type_0/mul_grad/Sum" + input: "gradients_4/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_4/layer_1_type_0/mul_grad/Reshape" + input: "gradients_4/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients_4/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/layer_1_type_0/add_grad/Shape" + input: "gradients_4/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_4/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients_4/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_4/layer_1_type_0/add_grad/Sum" + input: "gradients_4/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_4/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/AddN_3" + op: "AddN" + input: "gradients_4/add_4_grad/Reshape" + input: "gradients_4/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_4/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_4/AddN_3" + input: "gradients_4/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients_4/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/layer_0_type_0/add_grad/Shape" + input: "gradients_4/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_4/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients_4/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_4/layer_0_type_0/add_grad/Sum" + input: "gradients_4/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_4/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients_4/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients_4/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/Slice_2_grad/stack" + op: "Pack" + input: "gradients_4/Slice_2_grad/Rank" + input: "gradients_4/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients_4/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_2_grad/sub" + op: "Sub" + input: "gradients_4/Slice_2_grad/Shape_1" + input: "gradients_4/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_4/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/Slice_2_grad/sub_1" + input: "gradients_4/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_4/Slice_2_grad/Reshape" + input: "gradients_4/Slice_2_grad/Reshape_1" + input: "gradients_4/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 + } + } +} +node { + name: "gradients_4/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_4/Reshape_15_grad/Reshape" + input: "gradients_4/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_4/Slice_2_grad/Pad" + input: "gradients_4/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients_4/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_4/concat_grad/mod" + input: "gradients_4/concat_grad/ShapeN" + input: "gradients_4/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_4/concat_grad/Slice" + op: "Slice" + input: "gradients_4/Reshape_13_grad/Reshape" + input: "gradients_4/concat_grad/ConcatOffset" + input: "gradients_4/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/concat_grad/Slice_1" + op: "Slice" + input: "gradients_4/Reshape_13_grad/Reshape" + input: "gradients_4/concat_grad/ConcatOffset:1" + input: "gradients_4/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_4/concat_grad/Slice" + input: "gradients_4/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_4/concat_grad/Slice_1" + input: "gradients_4/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_4/Reshape_7_grad/Reshape" + input: "gradients_4/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_4/Reshape_11_grad/Reshape" + input: "gradients_4/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients_4/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients_4/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_4/filter_type_0/MatMul_8_grad/Shape" + input: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_4/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients_4/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients_4/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/MatMul_8_grad/Sum" + input: "gradients_4/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_4/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients_4/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients_4/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients_4/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients_4/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_4/filter_type_1/MatMul_8_grad/Shape" + input: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_4/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients_4/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients_4/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/MatMul_8_grad/Sum" + input: "gradients_4/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_4/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients_4/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients_4/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients_4/filter_type_0/Slice_4_grad/Rank" + input: "gradients_4/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients_4/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients_4/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients_4/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_4/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_0/Slice_4_grad/sub_1" + input: "gradients_4/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_4/filter_type_0/Slice_4_grad/Reshape" + input: "gradients_4/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients_4/filter_type_0/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 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_4/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients_4/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients_4/filter_type_1/Slice_4_grad/Rank" + input: "gradients_4/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients_4/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients_4/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients_4/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_4/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_1/Slice_4_grad/sub_1" + input: "gradients_4/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_4/filter_type_1/Slice_4_grad/Reshape" + input: "gradients_4/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients_4/filter_type_1/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 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_4/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients_4/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_4" + op: "AddN" + input: "gradients_4/filter_type_0/Slice_5_grad/Pad" + input: "gradients_4/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients_4/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_4/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/mul_grad/Shape" + input: "gradients_4/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_4/AddN_4" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_0/mul_grad/Mul" + input: "gradients_4/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/mul_grad/Sum" + input: "gradients_4/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_5" + op: "AddN" + input: "gradients_4/filter_type_1/Slice_5_grad/Pad" + input: "gradients_4/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients_4/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_4/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/mul_grad/Shape" + input: "gradients_4/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_4/AddN_5" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_1/mul_grad/Mul" + input: "gradients_4/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/mul_grad/Sum" + input: "gradients_4/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/add_10_grad/Shape" + input: "gradients_4/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_0/mul_grad/Reshape" + input: "gradients_4/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_10_grad/Sum" + input: "gradients_4/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_4/filter_type_0/mul_grad/Reshape" + input: "gradients_4/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_0/add_10_grad/Sum_1" + input: "gradients_4/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/add_10_grad/Shape" + input: "gradients_4/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_1/mul_grad/Reshape" + input: "gradients_4/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_10_grad/Sum" + input: "gradients_4/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_4/filter_type_1/mul_grad/Reshape" + input: "gradients_4/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_1/add_10_grad/Sum_1" + input: "gradients_4/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients_4/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients_4/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_4/filter_type_0/MatMul_3_grad/Shape" + input: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_4/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients_4/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients_4/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/MatMul_3_grad/Sum" + input: "gradients_4/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_4/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients_4/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients_4/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients_4/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients_4/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_4/filter_type_0/MatMul_7_grad/Shape" + input: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_4/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients_4/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients_4/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/MatMul_7_grad/Sum" + input: "gradients_4/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_4/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients_4/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients_4/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients_4/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients_4/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_4/filter_type_1/MatMul_3_grad/Shape" + input: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_4/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients_4/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients_4/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/MatMul_3_grad/Sum" + input: "gradients_4/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_4/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients_4/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients_4/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients_4/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients_4/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_4/filter_type_1/MatMul_7_grad/Shape" + input: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_4/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_4/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients_4/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients_4/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/MatMul_7_grad/Sum" + input: "gradients_4/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_4/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients_4/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients_4/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients_4/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients_4/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients_4/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients_4/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients_4/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients_4/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients_4/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients_4/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/add_4_grad/Shape" + input: "gradients_4/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_4/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_4_grad/Sum" + input: "gradients_4/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_4/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_4/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_0/add_4_grad/Sum_1" + input: "gradients_4/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/add_9_grad/Shape" + input: "gradients_4/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_4/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_9_grad/Sum" + input: "gradients_4/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_4/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_4/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_0/add_9_grad/Sum_1" + input: "gradients_4/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/add_4_grad/Shape" + input: "gradients_4/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_4/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_4_grad/Sum" + input: "gradients_4/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_4/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_4/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_1/add_4_grad/Sum_1" + input: "gradients_4/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/add_9_grad/Shape" + input: "gradients_4/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_4/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_9_grad/Sum" + input: "gradients_4/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_4/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_4/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_1/add_9_grad/Sum_1" + input: "gradients_4/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_0/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_1/axis" + input: "gradients_4/filter_type_0/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_2" + input: "filter_type_0/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_4/filter_type_0/concat_1_grad/mod" + input: "gradients_4/filter_type_0/concat_1_grad/ShapeN" + input: "gradients_4/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_1_grad/Slice" + op: "Slice" + input: "gradients_4/filter_type_0/add_4_grad/Reshape" + input: "gradients_4/filter_type_0/concat_1_grad/ConcatOffset" + input: "gradients_4/filter_type_0/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_4/filter_type_0/add_4_grad/Reshape" + input: "gradients_4/filter_type_0/concat_1_grad/ConcatOffset:1" + input: "gradients_4/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_4_grad/Reshape_1" + input: "gradients_4/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_0/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_3/axis" + input: "gradients_4/filter_type_0/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_7" + input: "filter_type_0/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_4/filter_type_0/concat_3_grad/mod" + input: "gradients_4/filter_type_0/concat_3_grad/ShapeN" + input: "gradients_4/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_3_grad/Slice" + op: "Slice" + input: "gradients_4/filter_type_0/add_9_grad/Reshape" + input: "gradients_4/filter_type_0/concat_3_grad/ConcatOffset" + input: "gradients_4/filter_type_0/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_4/filter_type_0/add_9_grad/Reshape" + input: "gradients_4/filter_type_0/concat_3_grad/ConcatOffset:1" + input: "gradients_4/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_9_grad/Reshape_1" + input: "gradients_4/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_1/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_1/axis" + input: "gradients_4/filter_type_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_2" + input: "filter_type_1/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_4/filter_type_1/concat_1_grad/mod" + input: "gradients_4/filter_type_1/concat_1_grad/ShapeN" + input: "gradients_4/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients_4/filter_type_1/add_4_grad/Reshape" + input: "gradients_4/filter_type_1/concat_1_grad/ConcatOffset" + input: "gradients_4/filter_type_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_4/filter_type_1/add_4_grad/Reshape" + input: "gradients_4/filter_type_1/concat_1_grad/ConcatOffset:1" + input: "gradients_4/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_4_grad/Reshape_1" + input: "gradients_4/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_1/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_3/axis" + input: "gradients_4/filter_type_1/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_7" + input: "filter_type_1/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_4/filter_type_1/concat_3_grad/mod" + input: "gradients_4/filter_type_1/concat_3_grad/ShapeN" + input: "gradients_4/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_3_grad/Slice" + op: "Slice" + input: "gradients_4/filter_type_1/add_9_grad/Reshape" + input: "gradients_4/filter_type_1/concat_3_grad/ConcatOffset" + input: "gradients_4/filter_type_1/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_4/filter_type_1/add_9_grad/Reshape" + input: "gradients_4/filter_type_1/concat_3_grad/ConcatOffset:1" + input: "gradients_4/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_9_grad/Reshape_1" + input: "gradients_4/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients_4/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients_4/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients_4/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients_4/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/add_3_grad/Shape" + input: "gradients_4/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients_4/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_3_grad/Sum" + input: "gradients_4/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/add_8_grad/Shape" + input: "gradients_4/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients_4/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_8_grad/Sum" + input: "gradients_4/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/add_3_grad/Shape" + input: "gradients_4/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients_4/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_3_grad/Sum" + input: "gradients_4/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/add_8_grad/Shape" + input: "gradients_4/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients_4/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_8_grad/Sum" + input: "gradients_4/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_4/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_4/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_4/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_4/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/AddN_6" + op: "AddN" + input: "gradients_4/filter_type_0/concat_1_grad/Slice" + input: "gradients_4/filter_type_0/concat_1_grad/Slice_1" + input: "gradients_4/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_0/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_4/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/add_2_grad/Shape" + input: "gradients_4/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients_4/AddN_6" + input: "gradients_4/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_2_grad/Sum" + input: "gradients_4/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_4/AddN_6" + input: "gradients_4/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_0/add_2_grad/Sum_1" + input: "gradients_4/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_7" + op: "AddN" + input: "gradients_4/filter_type_0/concat_3_grad/Slice" + input: "gradients_4/filter_type_0/concat_3_grad/Slice_1" + input: "gradients_4/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_0/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_4/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/add_7_grad/Shape" + input: "gradients_4/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients_4/AddN_7" + input: "gradients_4/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_7_grad/Sum" + input: "gradients_4/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_4/AddN_7" + input: "gradients_4/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_0/add_7_grad/Sum_1" + input: "gradients_4/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_8" + op: "AddN" + input: "gradients_4/filter_type_1/concat_1_grad/Slice" + input: "gradients_4/filter_type_1/concat_1_grad/Slice_1" + input: "gradients_4/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_1/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_4/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/add_2_grad/Shape" + input: "gradients_4/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients_4/AddN_8" + input: "gradients_4/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_2_grad/Sum" + input: "gradients_4/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_4/AddN_8" + input: "gradients_4/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_1/add_2_grad/Sum_1" + input: "gradients_4/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_9" + op: "AddN" + input: "gradients_4/filter_type_1/concat_3_grad/Slice" + input: "gradients_4/filter_type_1/concat_3_grad/Slice_1" + input: "gradients_4/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_1/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_4/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/add_7_grad/Shape" + input: "gradients_4/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients_4/AddN_9" + input: "gradients_4/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_7_grad/Sum" + input: "gradients_4/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_4/AddN_9" + input: "gradients_4/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_1/add_7_grad/Sum_1" + input: "gradients_4/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_0/concat_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat/axis" + input: "gradients_4/filter_type_0/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_4/filter_type_0/concat_grad/mod" + input: "gradients_4/filter_type_0/concat_grad/ShapeN" + input: "gradients_4/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_grad/Slice" + op: "Slice" + input: "gradients_4/filter_type_0/add_2_grad/Reshape" + input: "gradients_4/filter_type_0/concat_grad/ConcatOffset" + input: "gradients_4/filter_type_0/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/concat_grad/Slice_1" + op: "Slice" + input: "gradients_4/filter_type_0/add_2_grad/Reshape" + input: "gradients_4/filter_type_0/concat_grad/ConcatOffset:1" + input: "gradients_4/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_2_grad/Reshape_1" + input: "gradients_4/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_0/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_2/axis" + input: "gradients_4/filter_type_0/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_4/filter_type_0/concat_2_grad/mod" + input: "gradients_4/filter_type_0/concat_2_grad/ShapeN" + input: "gradients_4/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_4/filter_type_0/concat_2_grad/Slice" + op: "Slice" + input: "gradients_4/filter_type_0/add_7_grad/Reshape" + input: "gradients_4/filter_type_0/concat_2_grad/ConcatOffset" + input: "gradients_4/filter_type_0/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_4/filter_type_0/add_7_grad/Reshape" + input: "gradients_4/filter_type_0/concat_2_grad/ConcatOffset:1" + input: "gradients_4/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_7_grad/Reshape_1" + input: "gradients_4/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_1/concat_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat/axis" + input: "gradients_4/filter_type_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_4/filter_type_1/concat_grad/mod" + input: "gradients_4/filter_type_1/concat_grad/ShapeN" + input: "gradients_4/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_grad/Slice" + op: "Slice" + input: "gradients_4/filter_type_1/add_2_grad/Reshape" + input: "gradients_4/filter_type_1/concat_grad/ConcatOffset" + input: "gradients_4/filter_type_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients_4/filter_type_1/add_2_grad/Reshape" + input: "gradients_4/filter_type_1/concat_grad/ConcatOffset:1" + input: "gradients_4/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_2_grad/Reshape_1" + input: "gradients_4/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_1/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_2/axis" + input: "gradients_4/filter_type_1/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_4/filter_type_1/concat_2_grad/mod" + input: "gradients_4/filter_type_1/concat_2_grad/ShapeN" + input: "gradients_4/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_4/filter_type_1/concat_2_grad/Slice" + op: "Slice" + input: "gradients_4/filter_type_1/add_7_grad/Reshape" + input: "gradients_4/filter_type_1/concat_2_grad/ConcatOffset" + input: "gradients_4/filter_type_1/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_4/filter_type_1/add_7_grad/Reshape" + input: "gradients_4/filter_type_1/concat_2_grad/ConcatOffset:1" + input: "gradients_4/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_7_grad/Reshape_1" + input: "gradients_4/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients_4/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients_4/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients_4/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients_4/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/add_1_grad/Shape" + input: "gradients_4/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients_4/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_1_grad/Sum" + input: "gradients_4/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/add_6_grad/Shape" + input: "gradients_4/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients_4/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_6_grad/Sum" + input: "gradients_4/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/add_1_grad/Shape" + input: "gradients_4/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients_4/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_1_grad/Sum" + input: "gradients_4/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/add_6_grad/Shape" + input: "gradients_4/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients_4/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_6_grad/Sum" + input: "gradients_4/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_4/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_4/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_4/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_4/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/AddN_10" + op: "AddN" + input: "gradients_4/filter_type_0/concat_grad/Slice" + input: "gradients_4/filter_type_0/concat_grad/Slice_1" + input: "gradients_4/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_0/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_4/AddN_10" + input: "gradients_4/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_11" + op: "AddN" + input: "gradients_4/filter_type_0/concat_2_grad/Slice" + input: "gradients_4/filter_type_0/concat_2_grad/Slice_1" + input: "gradients_4/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_0/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_4/AddN_11" + input: "gradients_4/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_12" + op: "AddN" + input: "gradients_4/filter_type_1/concat_grad/Slice" + input: "gradients_4/filter_type_1/concat_grad/Slice_1" + input: "gradients_4/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_1/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_4/AddN_12" + input: "gradients_4/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_13" + op: "AddN" + input: "gradients_4/filter_type_1/concat_2_grad/Slice" + input: "gradients_4/filter_type_1/concat_2_grad/Slice_1" + input: "gradients_4/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_1/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_4/AddN_13" + input: "gradients_4/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients_4/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients_4/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients_4/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients_4/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_4/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/add_grad/Shape" + input: "gradients_4/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients_4/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_grad/Sum" + input: "gradients_4/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_0/add_5_grad/Shape" + input: "gradients_4/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients_4/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/add_5_grad/Sum" + input: "gradients_4/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/add_grad/Shape" + input: "gradients_4/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients_4/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_grad/Sum" + input: "gradients_4/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_4/filter_type_1/add_5_grad/Shape" + input: "gradients_4/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_4/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients_4/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_4/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/add_5_grad/Sum" + input: "gradients_4/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_4/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_4/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_4/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_4/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/MatMul_grad/MatMul" + input: "gradients_4/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients_4/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/MatMul_grad/MatMul" + input: "gradients_4/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients_4/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients_4/filter_type_0/Slice_1_grad/Rank" + input: "gradients_4/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients_4/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients_4/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients_4/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_4/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_0/Slice_1_grad/sub_1" + input: "gradients_4/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_4/filter_type_0/Slice_1_grad/Reshape" + input: "gradients_4/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients_4/filter_type_0/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 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_4/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients_4/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients_4/filter_type_0/Slice_3_grad/Rank" + input: "gradients_4/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients_4/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients_4/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients_4/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_4/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_0/Slice_3_grad/sub_1" + input: "gradients_4/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_4/filter_type_0/Slice_3_grad/Reshape" + input: "gradients_4/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients_4/filter_type_0/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 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_4/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients_4/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_4/filter_type_1/Slice_1_grad/Rank" + input: "gradients_4/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients_4/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_4/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients_4/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_4/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_1/Slice_1_grad/sub_1" + input: "gradients_4/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_4/filter_type_1/Slice_1_grad/Reshape" + input: "gradients_4/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients_4/filter_type_1/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 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_4/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients_4/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_4/filter_type_1/Slice_3_grad/Rank" + input: "gradients_4/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients_4/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_4/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients_4/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_4/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_1/Slice_3_grad/sub_1" + input: "gradients_4/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_4/filter_type_1/Slice_3_grad/Reshape" + input: "gradients_4/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients_4/filter_type_1/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 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_4/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients_4/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/Slice_1_grad/Pad" + input: "gradients_4/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_0/Slice_3_grad/Pad" + input: "gradients_4/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/Slice_1_grad/Pad" + input: "gradients_4/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_4/filter_type_1/Slice_3_grad/Pad" + input: "gradients_4/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_14" + op: "AddN" + input: "gradients_4/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients_4/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients_4/filter_type_0/Slice_grad/Rank" + input: "gradients_4/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients_4/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients_4/filter_type_0/Slice_grad/Shape_1" + input: "gradients_4/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients_4/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_0/Slice_grad/sub_1" + input: "gradients_4/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_4/filter_type_0/Slice_grad/Reshape" + input: "gradients_4/filter_type_0/Slice_grad/Reshape_1" + input: "gradients_4/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients_4/AddN_14" + input: "gradients_4/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_15" + op: "AddN" + input: "gradients_4/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients_4/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients_4/filter_type_0/Slice_2_grad/Rank" + input: "gradients_4/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients_4/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients_4/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients_4/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_4/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_0/Slice_2_grad/sub_1" + input: "gradients_4/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_4/filter_type_0/Slice_2_grad/Reshape" + input: "gradients_4/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients_4/filter_type_0/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 + } + } +} +node { + name: "gradients_4/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_4/AddN_15" + input: "gradients_4/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_16" + op: "AddN" + input: "gradients_4/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients_4/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients_4/filter_type_1/Slice_grad/Rank" + input: "gradients_4/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients_4/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients_4/filter_type_1/Slice_grad/Shape_1" + input: "gradients_4/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_4/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_1/Slice_grad/sub_1" + input: "gradients_4/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_4/filter_type_1/Slice_grad/Reshape" + input: "gradients_4/filter_type_1/Slice_grad/Reshape_1" + input: "gradients_4/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_4/AddN_16" + input: "gradients_4/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_17" + op: "AddN" + input: "gradients_4/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients_4/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_4/filter_type_1/Slice_2_grad/Rank" + input: "gradients_4/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients_4/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_4/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients_4/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_4/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/filter_type_1/Slice_2_grad/sub_1" + input: "gradients_4/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_4/filter_type_1/Slice_2_grad/Reshape" + input: "gradients_4/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients_4/filter_type_1/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 + } + } +} +node { + name: "gradients_4/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_4/AddN_17" + input: "gradients_4/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_18" + op: "AddN" + input: "gradients_4/filter_type_0/Slice_grad/Pad" + input: "gradients_4/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_4/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_4/AddN_18" + input: "gradients_4/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_19" + op: "AddN" + input: "gradients_4/filter_type_1/Slice_grad/Pad" + input: "gradients_4/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_4/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_4/AddN_19" + input: "gradients_4/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/Slice_grad/stack" + op: "Pack" + input: "gradients_4/Slice_grad/Rank" + input: "gradients_4/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients_4/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_grad/sub" + op: "Sub" + input: "gradients_4/Slice_grad/Shape_1" + input: "gradients_4/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_grad/sub_1" + op: "Sub" + input: "gradients_4/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/Slice_grad/sub_1" + input: "gradients_4/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_4/Slice_grad/Reshape" + input: "gradients_4/Slice_grad/Reshape_1" + input: "gradients_4/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_grad/Pad" + op: "Pad" + input: "gradients_4/Reshape_5_grad/Reshape" + input: "gradients_4/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_4/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/Slice_1_grad/stack" + op: "Pack" + input: "gradients_4/Slice_1_grad/Rank" + input: "gradients_4/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_4/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients_4/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_1_grad/sub" + op: "Sub" + input: "gradients_4/Slice_1_grad/Shape_1" + input: "gradients_4/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_4/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_4/Slice_1_grad/sub_1" + input: "gradients_4/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_4/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_4/Slice_1_grad/Reshape" + input: "gradients_4/Slice_1_grad/Reshape_1" + input: "gradients_4/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 + } + } +} +node { + name: "gradients_4/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_4/Reshape_9_grad/Reshape" + input: "gradients_4/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/AddN_20" + op: "AddN" + input: "gradients_4/Slice_grad/Pad" + input: "gradients_4/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_4/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_4/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_4/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_4/AddN_20" + input: "gradients_4/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_46/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_46/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_46/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_46" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_46/stack" + input: "strided_slice_46/stack_1" + input: "strided_slice_46/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_35/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_35" + op: "Mul" + input: "strided_slice_46" + input: "mul_35/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_39/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_39/shape" + op: "Pack" + input: "Reshape_39/shape/0" + input: "mul_35" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_39" + op: "Reshape" + input: "gradients_4/Reshape_4_grad/Reshape" + input: "Reshape_39/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA_4" + op: "ProdForceSeA" + input: "Reshape_39" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA_4" + op: "ProdVirialSeA" + input: "Reshape_39" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_47/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_47/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_47/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_47" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_47/stack" + input: "strided_slice_47/stack_1" + input: "strided_slice_47/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_36/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_36" + op: "Mul" + input: "mul_36/x" + input: "strided_slice_47" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_40/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_40/shape" + op: "Pack" + input: "Reshape_40/shape/0" + input: "mul_36" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_40" + op: "Reshape" + input: "ProdForceSeA_4" + input: "Reshape_40/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_41/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_41" + op: "Reshape" + input: "ProdVirialSeA_4" + input: "Reshape_41/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_48/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_48/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_48/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_48" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_48/stack" + input: "strided_slice_48/stack_1" + input: "strided_slice_48/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_37/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_37" + op: "Mul" + input: "mul_37/x" + input: "strided_slice_48" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_42/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_42/shape" + op: "Pack" + input: "Reshape_42/shape/0" + input: "mul_37" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_42" + op: "Reshape" + input: "ProdVirialSeA_4:1" + input: "Reshape_42/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Shape" + op: "Shape" + input: "split:5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients_5/grad_ys_0" + op: "Fill" + input: "gradients_5/Shape" + input: "gradients_5/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/zeros_like" + op: "ZerosLike" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/zeros_like_1" + op: "ZerosLike" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/zeros_like_2" + op: "ZerosLike" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/zeros_like_3" + op: "ZerosLike" + input: "split:3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/zeros_like_4" + op: "ZerosLike" + input: "split:4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/zeros_like_5" + op: "ZerosLike" + input: "split:6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/zeros_like_6" + op: "ZerosLike" + input: "split:7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/zeros_like_7" + op: "ZerosLike" + input: "split:8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/split_grad/concat" + op: "ConcatV2" + input: "gradients_5/zeros_like" + input: "gradients_5/zeros_like_1" + input: "gradients_5/zeros_like_2" + input: "gradients_5/zeros_like_3" + input: "gradients_5/zeros_like_4" + input: "gradients_5/grad_ys_0" + input: "gradients_5/zeros_like_5" + input: "gradients_5/zeros_like_6" + input: "gradients_5/zeros_like_7" + input: "split/split_dim" + attr { + key: "N" + value { + i: 9 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_22_grad/Shape" + op: "Shape" + input: "o_polar" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients_5/split_grad/concat" + input: "gradients_5/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/o_polar_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/o_polar_grad/Reshape" + op: "Reshape" + input: "gradients_5/Reshape_22_grad/Reshape" + input: "gradients_5/o_polar_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_21_grad/Shape" + op: "Shape" + input: "add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients_5/o_polar_grad/Reshape" + input: "gradients_5/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_7_grad/Shape" + op: "Shape" + input: "mul_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_7_grad/Shape_1" + op: "Shape" + input: "mul_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/add_7_grad/Shape" + input: "gradients_5/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_7_grad/Sum" + op: "Sum" + input: "gradients_5/Reshape_21_grad/Reshape" + input: "gradients_5/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_5/add_7_grad/Sum" + input: "gradients_5/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/mul_16_grad/Shape" + op: "Shape" + input: "Reshape_18" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/mul_16_grad/Shape_1" + op: "Shape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/mul_16_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/mul_16_grad/Shape" + input: "gradients_5/mul_16_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/mul_16_grad/Mul" + op: "Mul" + input: "gradients_5/add_7_grad/Reshape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/mul_16_grad/Sum" + op: "Sum" + input: "gradients_5/mul_16_grad/Mul" + input: "gradients_5/mul_16_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/mul_16_grad/Reshape" + op: "Reshape" + input: "gradients_5/mul_16_grad/Sum" + input: "gradients_5/mul_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients_5/mul_16_grad/Reshape" + input: "gradients_5/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/MatMul_1_grad/MatMul" + op: "BatchMatMulV2" + input: "MatMul" + input: "gradients_5/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_5/MatMul_1_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_16" + input: "gradients_5/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_5/MatMul_1_grad/Shape" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/MatMul_1_grad/Shape_1" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/MatMul_1_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/MatMul_1_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/MatMul_1_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/MatMul_1_grad/strided_slice" + op: "StridedSlice" + input: "gradients_5/MatMul_1_grad/Shape" + input: "gradients_5/MatMul_1_grad/strided_slice/stack" + input: "gradients_5/MatMul_1_grad/strided_slice/stack_1" + input: "gradients_5/MatMul_1_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/MatMul_1_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/MatMul_1_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/MatMul_1_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/MatMul_1_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_5/MatMul_1_grad/Shape_1" + input: "gradients_5/MatMul_1_grad/strided_slice_1/stack" + input: "gradients_5/MatMul_1_grad/strided_slice_1/stack_1" + input: "gradients_5/MatMul_1_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/MatMul_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/MatMul_1_grad/strided_slice" + input: "gradients_5/MatMul_1_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/MatMul_1_grad/Sum" + op: "Sum" + input: "gradients_5/MatMul_1_grad/MatMul" + input: "gradients_5/MatMul_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/MatMul_1_grad/Reshape" + op: "Reshape" + input: "gradients_5/MatMul_1_grad/Sum" + input: "gradients_5/MatMul_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/MatMul_1_grad/Sum_1" + op: "Sum" + input: "gradients_5/MatMul_1_grad/MatMul_1" + input: "gradients_5/MatMul_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/MatMul_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/MatMul_1_grad/Sum_1" + input: "gradients_5/MatMul_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients_5/MatMul_1_grad/Reshape_1" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_5/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "add_6" + input: "gradients_5/MatMul_1_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_5/MatMul_grad/Shape" + op: "Shape" + input: "add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients_5/MatMul_grad/Shape" + input: "gradients_5/MatMul_grad/strided_slice/stack" + input: "gradients_5/MatMul_grad/strided_slice/stack_1" + input: "gradients_5/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_5/MatMul_grad/Shape_1" + input: "gradients_5/MatMul_grad/strided_slice_1/stack" + input: "gradients_5/MatMul_grad/strided_slice_1/stack_1" + input: "gradients_5/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/MatMul_grad/strided_slice" + input: "gradients_5/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/MatMul_grad/Sum" + op: "Sum" + input: "gradients_5/MatMul_grad/MatMul" + input: "gradients_5/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients_5/MatMul_grad/Sum" + input: "gradients_5/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients_5/MatMul_grad/MatMul_1" + input: "gradients_5/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/MatMul_grad/Sum_1" + input: "gradients_5/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_6_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_6_grad/Shape_1" + op: "Shape" + input: "transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/add_6_grad/Shape" + input: "gradients_5/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_6_grad/Sum" + op: "Sum" + input: "gradients_5/MatMul_grad/Reshape" + input: "gradients_5/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_5/add_6_grad/Sum" + input: "gradients_5/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_6_grad/Sum_1" + op: "Sum" + input: "gradients_5/MatMul_grad/Reshape" + input: "gradients_5/add_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/add_6_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/add_6_grad/Sum_1" + input: "gradients_5/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN" + op: "AddN" + input: "gradients_5/MatMul_1_grad/Reshape" + input: "gradients_5/MatMul_grad/Reshape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/MatMul_1_grad/Reshape" + } + } + } +} +node { + name: "gradients_5/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients_5/AddN" + input: "gradients_5/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/transpose_grad/transpose" + op: "Transpose" + input: "gradients_5/add_6_grad/Reshape_1" + input: "gradients_5/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/Slice_3_grad/stack" + op: "Pack" + input: "gradients_5/Slice_3_grad/Rank" + input: "gradients_5/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients_5/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_3_grad/sub" + op: "Sub" + input: "gradients_5/Slice_3_grad/Shape_1" + input: "gradients_5/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_5/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/Slice_3_grad/sub_1" + input: "gradients_5/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_5/Slice_3_grad/Reshape" + input: "gradients_5/Slice_3_grad/Reshape_1" + input: "gradients_5/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 + } + } +} +node { + name: "gradients_5/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_5/Reshape_16_grad/Reshape" + input: "gradients_5/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_1" + op: "AddN" + input: "gradients_5/add_6_grad/Reshape" + input: "gradients_5/transpose_grad/transpose" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/add_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_5/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients_5/AddN_1" + input: "gradients_5/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_5/Slice_3_grad/Pad" + input: "gradients_5/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/final_layer_type_0/add_grad/Shape" + input: "gradients_5/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_5/Reshape_17_grad/Reshape" + input: "gradients_5/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_5/final_layer_type_0/add_grad/Sum" + input: "gradients_5/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_5/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients_5/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_5/concat_1_grad/mod" + input: "gradients_5/concat_1_grad/ShapeN" + input: "gradients_5/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_5/concat_1_grad/Slice" + op: "Slice" + input: "gradients_5/Reshape_14_grad/Reshape" + input: "gradients_5/concat_1_grad/ConcatOffset" + input: "gradients_5/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_5/Reshape_14_grad/Reshape" + input: "gradients_5/concat_1_grad/ConcatOffset:1" + input: "gradients_5/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/add_5_grad/Shape" + op: "Shape" + input: "add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_5_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/add_5_grad/Shape" + input: "gradients_5/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_5_grad/Sum" + op: "Sum" + input: "gradients_5/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_5/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_5/add_5_grad/Sum" + input: "gradients_5/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_5_grad/Sum_1" + op: "Sum" + input: "gradients_5/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_5/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/add_5_grad/Sum_1" + input: "gradients_5/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_5/concat_1_grad/Slice" + input: "gradients_5/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_5/concat_1_grad/Slice_1" + input: "gradients_5/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/layer_2_type_0/mul_grad/Shape" + input: "gradients_5/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_5/add_5_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_5/layer_2_type_0/mul_grad/Mul" + input: "gradients_5/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_5/layer_2_type_0/mul_grad/Sum" + input: "gradients_5/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients_5/Reshape_8_grad/Reshape" + input: "gradients_5/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients_5/Reshape_12_grad/Reshape" + input: "gradients_5/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_5/layer_2_type_0/mul_grad/Reshape" + input: "gradients_5/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients_5/filter_type_0/Slice_5_grad/Rank" + input: "gradients_5/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients_5/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients_5/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients_5/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_5/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_0/Slice_5_grad/sub_1" + input: "gradients_5/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_5/filter_type_0/Slice_5_grad/Reshape" + input: "gradients_5/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients_5/filter_type_0/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 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_5/filter_type_0/transpose_grad/transpose" + input: "gradients_5/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients_5/filter_type_1/Slice_5_grad/Rank" + input: "gradients_5/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients_5/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients_5/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients_5/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_5/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_1/Slice_5_grad/sub_1" + input: "gradients_5/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_5/filter_type_1/Slice_5_grad/Reshape" + input: "gradients_5/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients_5/filter_type_1/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 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_5/filter_type_1/transpose_grad/transpose" + input: "gradients_5/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients_5/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/layer_2_type_0/add_grad/Shape" + input: "gradients_5/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_5/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients_5/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_5/layer_2_type_0/add_grad/Sum" + input: "gradients_5/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_5/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/AddN_2" + op: "AddN" + input: "gradients_5/add_5_grad/Reshape" + input: "gradients_5/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients_5/add_4_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_4_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/add_4_grad/Shape" + input: "gradients_5/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_4_grad/Sum" + op: "Sum" + input: "gradients_5/AddN_2" + input: "gradients_5/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_5/add_4_grad/Sum" + input: "gradients_5/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_5/AddN_2" + input: "gradients_5/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/add_4_grad/Sum_1" + input: "gradients_5/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/layer_1_type_0/mul_grad/Shape" + input: "gradients_5/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_5/add_4_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_5/layer_1_type_0/mul_grad/Mul" + input: "gradients_5/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_5/layer_1_type_0/mul_grad/Sum" + input: "gradients_5/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_5/layer_1_type_0/mul_grad/Reshape" + input: "gradients_5/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients_5/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/layer_1_type_0/add_grad/Shape" + input: "gradients_5/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_5/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients_5/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_5/layer_1_type_0/add_grad/Sum" + input: "gradients_5/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_5/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/AddN_3" + op: "AddN" + input: "gradients_5/add_4_grad/Reshape" + input: "gradients_5/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_5/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_5/AddN_3" + input: "gradients_5/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients_5/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/layer_0_type_0/add_grad/Shape" + input: "gradients_5/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_5/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients_5/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_5/layer_0_type_0/add_grad/Sum" + input: "gradients_5/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_5/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients_5/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients_5/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/Slice_2_grad/stack" + op: "Pack" + input: "gradients_5/Slice_2_grad/Rank" + input: "gradients_5/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients_5/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_2_grad/sub" + op: "Sub" + input: "gradients_5/Slice_2_grad/Shape_1" + input: "gradients_5/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_5/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/Slice_2_grad/sub_1" + input: "gradients_5/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_5/Slice_2_grad/Reshape" + input: "gradients_5/Slice_2_grad/Reshape_1" + input: "gradients_5/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 + } + } +} +node { + name: "gradients_5/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_5/Reshape_15_grad/Reshape" + input: "gradients_5/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_5/Slice_2_grad/Pad" + input: "gradients_5/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients_5/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_5/concat_grad/mod" + input: "gradients_5/concat_grad/ShapeN" + input: "gradients_5/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_5/concat_grad/Slice" + op: "Slice" + input: "gradients_5/Reshape_13_grad/Reshape" + input: "gradients_5/concat_grad/ConcatOffset" + input: "gradients_5/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/concat_grad/Slice_1" + op: "Slice" + input: "gradients_5/Reshape_13_grad/Reshape" + input: "gradients_5/concat_grad/ConcatOffset:1" + input: "gradients_5/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_5/concat_grad/Slice" + input: "gradients_5/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_5/concat_grad/Slice_1" + input: "gradients_5/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_5/Reshape_7_grad/Reshape" + input: "gradients_5/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_5/Reshape_11_grad/Reshape" + input: "gradients_5/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients_5/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients_5/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_5/filter_type_0/MatMul_8_grad/Shape" + input: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_5/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients_5/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients_5/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/MatMul_8_grad/Sum" + input: "gradients_5/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_5/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients_5/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients_5/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients_5/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients_5/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_5/filter_type_1/MatMul_8_grad/Shape" + input: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_5/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients_5/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients_5/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/MatMul_8_grad/Sum" + input: "gradients_5/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_5/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients_5/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients_5/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients_5/filter_type_0/Slice_4_grad/Rank" + input: "gradients_5/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients_5/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients_5/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients_5/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_5/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_0/Slice_4_grad/sub_1" + input: "gradients_5/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_5/filter_type_0/Slice_4_grad/Reshape" + input: "gradients_5/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients_5/filter_type_0/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 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_5/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients_5/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients_5/filter_type_1/Slice_4_grad/Rank" + input: "gradients_5/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients_5/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients_5/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients_5/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_5/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_1/Slice_4_grad/sub_1" + input: "gradients_5/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_5/filter_type_1/Slice_4_grad/Reshape" + input: "gradients_5/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients_5/filter_type_1/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 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_5/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients_5/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_4" + op: "AddN" + input: "gradients_5/filter_type_0/Slice_5_grad/Pad" + input: "gradients_5/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients_5/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_5/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/mul_grad/Shape" + input: "gradients_5/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_5/AddN_4" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_0/mul_grad/Mul" + input: "gradients_5/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/mul_grad/Sum" + input: "gradients_5/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_5" + op: "AddN" + input: "gradients_5/filter_type_1/Slice_5_grad/Pad" + input: "gradients_5/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients_5/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_5/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/mul_grad/Shape" + input: "gradients_5/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_5/AddN_5" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_1/mul_grad/Mul" + input: "gradients_5/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/mul_grad/Sum" + input: "gradients_5/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/add_10_grad/Shape" + input: "gradients_5/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_0/mul_grad/Reshape" + input: "gradients_5/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_10_grad/Sum" + input: "gradients_5/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_5/filter_type_0/mul_grad/Reshape" + input: "gradients_5/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_0/add_10_grad/Sum_1" + input: "gradients_5/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/add_10_grad/Shape" + input: "gradients_5/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_1/mul_grad/Reshape" + input: "gradients_5/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_10_grad/Sum" + input: "gradients_5/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_5/filter_type_1/mul_grad/Reshape" + input: "gradients_5/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_1/add_10_grad/Sum_1" + input: "gradients_5/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients_5/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients_5/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_5/filter_type_0/MatMul_3_grad/Shape" + input: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_5/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients_5/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients_5/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/MatMul_3_grad/Sum" + input: "gradients_5/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_5/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients_5/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients_5/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients_5/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients_5/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_5/filter_type_0/MatMul_7_grad/Shape" + input: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_5/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients_5/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients_5/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/MatMul_7_grad/Sum" + input: "gradients_5/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_5/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients_5/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients_5/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients_5/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients_5/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_5/filter_type_1/MatMul_3_grad/Shape" + input: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_5/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients_5/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients_5/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/MatMul_3_grad/Sum" + input: "gradients_5/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_5/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients_5/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients_5/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients_5/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients_5/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_5/filter_type_1/MatMul_7_grad/Shape" + input: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_5/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_5/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients_5/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients_5/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/MatMul_7_grad/Sum" + input: "gradients_5/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_5/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients_5/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients_5/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients_5/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients_5/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients_5/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients_5/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients_5/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients_5/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients_5/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients_5/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/add_4_grad/Shape" + input: "gradients_5/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_5/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_4_grad/Sum" + input: "gradients_5/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_5/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_5/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_0/add_4_grad/Sum_1" + input: "gradients_5/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/add_9_grad/Shape" + input: "gradients_5/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_5/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_9_grad/Sum" + input: "gradients_5/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_5/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_5/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_0/add_9_grad/Sum_1" + input: "gradients_5/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/add_4_grad/Shape" + input: "gradients_5/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_5/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_4_grad/Sum" + input: "gradients_5/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_5/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_5/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_1/add_4_grad/Sum_1" + input: "gradients_5/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/add_9_grad/Shape" + input: "gradients_5/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_5/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_9_grad/Sum" + input: "gradients_5/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_5/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_5/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_1/add_9_grad/Sum_1" + input: "gradients_5/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_0/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_1/axis" + input: "gradients_5/filter_type_0/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_2" + input: "filter_type_0/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_5/filter_type_0/concat_1_grad/mod" + input: "gradients_5/filter_type_0/concat_1_grad/ShapeN" + input: "gradients_5/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_1_grad/Slice" + op: "Slice" + input: "gradients_5/filter_type_0/add_4_grad/Reshape" + input: "gradients_5/filter_type_0/concat_1_grad/ConcatOffset" + input: "gradients_5/filter_type_0/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_5/filter_type_0/add_4_grad/Reshape" + input: "gradients_5/filter_type_0/concat_1_grad/ConcatOffset:1" + input: "gradients_5/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_4_grad/Reshape_1" + input: "gradients_5/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_0/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_3/axis" + input: "gradients_5/filter_type_0/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_7" + input: "filter_type_0/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_5/filter_type_0/concat_3_grad/mod" + input: "gradients_5/filter_type_0/concat_3_grad/ShapeN" + input: "gradients_5/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_3_grad/Slice" + op: "Slice" + input: "gradients_5/filter_type_0/add_9_grad/Reshape" + input: "gradients_5/filter_type_0/concat_3_grad/ConcatOffset" + input: "gradients_5/filter_type_0/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_5/filter_type_0/add_9_grad/Reshape" + input: "gradients_5/filter_type_0/concat_3_grad/ConcatOffset:1" + input: "gradients_5/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_9_grad/Reshape_1" + input: "gradients_5/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_1/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_1/axis" + input: "gradients_5/filter_type_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_2" + input: "filter_type_1/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_5/filter_type_1/concat_1_grad/mod" + input: "gradients_5/filter_type_1/concat_1_grad/ShapeN" + input: "gradients_5/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients_5/filter_type_1/add_4_grad/Reshape" + input: "gradients_5/filter_type_1/concat_1_grad/ConcatOffset" + input: "gradients_5/filter_type_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_5/filter_type_1/add_4_grad/Reshape" + input: "gradients_5/filter_type_1/concat_1_grad/ConcatOffset:1" + input: "gradients_5/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_4_grad/Reshape_1" + input: "gradients_5/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_1/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_3/axis" + input: "gradients_5/filter_type_1/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_7" + input: "filter_type_1/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_5/filter_type_1/concat_3_grad/mod" + input: "gradients_5/filter_type_1/concat_3_grad/ShapeN" + input: "gradients_5/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_3_grad/Slice" + op: "Slice" + input: "gradients_5/filter_type_1/add_9_grad/Reshape" + input: "gradients_5/filter_type_1/concat_3_grad/ConcatOffset" + input: "gradients_5/filter_type_1/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_5/filter_type_1/add_9_grad/Reshape" + input: "gradients_5/filter_type_1/concat_3_grad/ConcatOffset:1" + input: "gradients_5/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_9_grad/Reshape_1" + input: "gradients_5/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients_5/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients_5/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients_5/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients_5/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/add_3_grad/Shape" + input: "gradients_5/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients_5/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_3_grad/Sum" + input: "gradients_5/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/add_8_grad/Shape" + input: "gradients_5/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients_5/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_8_grad/Sum" + input: "gradients_5/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/add_3_grad/Shape" + input: "gradients_5/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients_5/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_3_grad/Sum" + input: "gradients_5/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/add_8_grad/Shape" + input: "gradients_5/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients_5/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_8_grad/Sum" + input: "gradients_5/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_5/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_5/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_5/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_5/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/AddN_6" + op: "AddN" + input: "gradients_5/filter_type_0/concat_1_grad/Slice" + input: "gradients_5/filter_type_0/concat_1_grad/Slice_1" + input: "gradients_5/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_0/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_5/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/add_2_grad/Shape" + input: "gradients_5/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients_5/AddN_6" + input: "gradients_5/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_2_grad/Sum" + input: "gradients_5/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_5/AddN_6" + input: "gradients_5/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_0/add_2_grad/Sum_1" + input: "gradients_5/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_7" + op: "AddN" + input: "gradients_5/filter_type_0/concat_3_grad/Slice" + input: "gradients_5/filter_type_0/concat_3_grad/Slice_1" + input: "gradients_5/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_0/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_5/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/add_7_grad/Shape" + input: "gradients_5/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients_5/AddN_7" + input: "gradients_5/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_7_grad/Sum" + input: "gradients_5/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_5/AddN_7" + input: "gradients_5/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_0/add_7_grad/Sum_1" + input: "gradients_5/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_8" + op: "AddN" + input: "gradients_5/filter_type_1/concat_1_grad/Slice" + input: "gradients_5/filter_type_1/concat_1_grad/Slice_1" + input: "gradients_5/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_1/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_5/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/add_2_grad/Shape" + input: "gradients_5/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients_5/AddN_8" + input: "gradients_5/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_2_grad/Sum" + input: "gradients_5/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_5/AddN_8" + input: "gradients_5/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_1/add_2_grad/Sum_1" + input: "gradients_5/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_9" + op: "AddN" + input: "gradients_5/filter_type_1/concat_3_grad/Slice" + input: "gradients_5/filter_type_1/concat_3_grad/Slice_1" + input: "gradients_5/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_1/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_5/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/add_7_grad/Shape" + input: "gradients_5/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients_5/AddN_9" + input: "gradients_5/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_7_grad/Sum" + input: "gradients_5/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_5/AddN_9" + input: "gradients_5/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_1/add_7_grad/Sum_1" + input: "gradients_5/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_0/concat_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat/axis" + input: "gradients_5/filter_type_0/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_5/filter_type_0/concat_grad/mod" + input: "gradients_5/filter_type_0/concat_grad/ShapeN" + input: "gradients_5/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_grad/Slice" + op: "Slice" + input: "gradients_5/filter_type_0/add_2_grad/Reshape" + input: "gradients_5/filter_type_0/concat_grad/ConcatOffset" + input: "gradients_5/filter_type_0/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/concat_grad/Slice_1" + op: "Slice" + input: "gradients_5/filter_type_0/add_2_grad/Reshape" + input: "gradients_5/filter_type_0/concat_grad/ConcatOffset:1" + input: "gradients_5/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_2_grad/Reshape_1" + input: "gradients_5/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_0/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_2/axis" + input: "gradients_5/filter_type_0/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_5/filter_type_0/concat_2_grad/mod" + input: "gradients_5/filter_type_0/concat_2_grad/ShapeN" + input: "gradients_5/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_5/filter_type_0/concat_2_grad/Slice" + op: "Slice" + input: "gradients_5/filter_type_0/add_7_grad/Reshape" + input: "gradients_5/filter_type_0/concat_2_grad/ConcatOffset" + input: "gradients_5/filter_type_0/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_5/filter_type_0/add_7_grad/Reshape" + input: "gradients_5/filter_type_0/concat_2_grad/ConcatOffset:1" + input: "gradients_5/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_7_grad/Reshape_1" + input: "gradients_5/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_1/concat_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat/axis" + input: "gradients_5/filter_type_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_5/filter_type_1/concat_grad/mod" + input: "gradients_5/filter_type_1/concat_grad/ShapeN" + input: "gradients_5/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_grad/Slice" + op: "Slice" + input: "gradients_5/filter_type_1/add_2_grad/Reshape" + input: "gradients_5/filter_type_1/concat_grad/ConcatOffset" + input: "gradients_5/filter_type_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients_5/filter_type_1/add_2_grad/Reshape" + input: "gradients_5/filter_type_1/concat_grad/ConcatOffset:1" + input: "gradients_5/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_2_grad/Reshape_1" + input: "gradients_5/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_1/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_2/axis" + input: "gradients_5/filter_type_1/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_5/filter_type_1/concat_2_grad/mod" + input: "gradients_5/filter_type_1/concat_2_grad/ShapeN" + input: "gradients_5/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_5/filter_type_1/concat_2_grad/Slice" + op: "Slice" + input: "gradients_5/filter_type_1/add_7_grad/Reshape" + input: "gradients_5/filter_type_1/concat_2_grad/ConcatOffset" + input: "gradients_5/filter_type_1/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_5/filter_type_1/add_7_grad/Reshape" + input: "gradients_5/filter_type_1/concat_2_grad/ConcatOffset:1" + input: "gradients_5/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_7_grad/Reshape_1" + input: "gradients_5/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients_5/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients_5/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients_5/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients_5/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/add_1_grad/Shape" + input: "gradients_5/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients_5/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_1_grad/Sum" + input: "gradients_5/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/add_6_grad/Shape" + input: "gradients_5/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients_5/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_6_grad/Sum" + input: "gradients_5/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/add_1_grad/Shape" + input: "gradients_5/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients_5/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_1_grad/Sum" + input: "gradients_5/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/add_6_grad/Shape" + input: "gradients_5/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients_5/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_6_grad/Sum" + input: "gradients_5/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_5/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_5/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_5/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_5/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/AddN_10" + op: "AddN" + input: "gradients_5/filter_type_0/concat_grad/Slice" + input: "gradients_5/filter_type_0/concat_grad/Slice_1" + input: "gradients_5/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_0/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_5/AddN_10" + input: "gradients_5/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_11" + op: "AddN" + input: "gradients_5/filter_type_0/concat_2_grad/Slice" + input: "gradients_5/filter_type_0/concat_2_grad/Slice_1" + input: "gradients_5/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_0/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_5/AddN_11" + input: "gradients_5/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_12" + op: "AddN" + input: "gradients_5/filter_type_1/concat_grad/Slice" + input: "gradients_5/filter_type_1/concat_grad/Slice_1" + input: "gradients_5/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_1/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_5/AddN_12" + input: "gradients_5/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_13" + op: "AddN" + input: "gradients_5/filter_type_1/concat_2_grad/Slice" + input: "gradients_5/filter_type_1/concat_2_grad/Slice_1" + input: "gradients_5/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_1/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_5/AddN_13" + input: "gradients_5/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients_5/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients_5/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients_5/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients_5/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_5/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/add_grad/Shape" + input: "gradients_5/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients_5/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_grad/Sum" + input: "gradients_5/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_0/add_5_grad/Shape" + input: "gradients_5/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients_5/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/add_5_grad/Sum" + input: "gradients_5/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/add_grad/Shape" + input: "gradients_5/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients_5/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_grad/Sum" + input: "gradients_5/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_5/filter_type_1/add_5_grad/Shape" + input: "gradients_5/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_5/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients_5/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_5/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/add_5_grad/Sum" + input: "gradients_5/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_5/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_5/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_5/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_5/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/MatMul_grad/MatMul" + input: "gradients_5/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients_5/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/MatMul_grad/MatMul" + input: "gradients_5/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients_5/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients_5/filter_type_0/Slice_1_grad/Rank" + input: "gradients_5/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients_5/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients_5/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients_5/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_5/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_0/Slice_1_grad/sub_1" + input: "gradients_5/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_5/filter_type_0/Slice_1_grad/Reshape" + input: "gradients_5/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients_5/filter_type_0/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 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_5/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients_5/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients_5/filter_type_0/Slice_3_grad/Rank" + input: "gradients_5/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients_5/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients_5/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients_5/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_5/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_0/Slice_3_grad/sub_1" + input: "gradients_5/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_5/filter_type_0/Slice_3_grad/Reshape" + input: "gradients_5/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients_5/filter_type_0/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 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_5/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients_5/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_5/filter_type_1/Slice_1_grad/Rank" + input: "gradients_5/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients_5/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_5/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients_5/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_5/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_1/Slice_1_grad/sub_1" + input: "gradients_5/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_5/filter_type_1/Slice_1_grad/Reshape" + input: "gradients_5/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients_5/filter_type_1/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 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_5/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients_5/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_5/filter_type_1/Slice_3_grad/Rank" + input: "gradients_5/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients_5/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_5/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients_5/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_5/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_1/Slice_3_grad/sub_1" + input: "gradients_5/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_5/filter_type_1/Slice_3_grad/Reshape" + input: "gradients_5/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients_5/filter_type_1/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 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_5/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients_5/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/Slice_1_grad/Pad" + input: "gradients_5/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_0/Slice_3_grad/Pad" + input: "gradients_5/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/Slice_1_grad/Pad" + input: "gradients_5/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_5/filter_type_1/Slice_3_grad/Pad" + input: "gradients_5/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_14" + op: "AddN" + input: "gradients_5/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients_5/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients_5/filter_type_0/Slice_grad/Rank" + input: "gradients_5/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients_5/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients_5/filter_type_0/Slice_grad/Shape_1" + input: "gradients_5/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients_5/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_0/Slice_grad/sub_1" + input: "gradients_5/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_5/filter_type_0/Slice_grad/Reshape" + input: "gradients_5/filter_type_0/Slice_grad/Reshape_1" + input: "gradients_5/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients_5/AddN_14" + input: "gradients_5/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_15" + op: "AddN" + input: "gradients_5/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients_5/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients_5/filter_type_0/Slice_2_grad/Rank" + input: "gradients_5/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients_5/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients_5/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients_5/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_5/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_0/Slice_2_grad/sub_1" + input: "gradients_5/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_5/filter_type_0/Slice_2_grad/Reshape" + input: "gradients_5/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients_5/filter_type_0/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 + } + } +} +node { + name: "gradients_5/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_5/AddN_15" + input: "gradients_5/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_16" + op: "AddN" + input: "gradients_5/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients_5/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients_5/filter_type_1/Slice_grad/Rank" + input: "gradients_5/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients_5/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients_5/filter_type_1/Slice_grad/Shape_1" + input: "gradients_5/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_5/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_1/Slice_grad/sub_1" + input: "gradients_5/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_5/filter_type_1/Slice_grad/Reshape" + input: "gradients_5/filter_type_1/Slice_grad/Reshape_1" + input: "gradients_5/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_5/AddN_16" + input: "gradients_5/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_17" + op: "AddN" + input: "gradients_5/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients_5/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_5/filter_type_1/Slice_2_grad/Rank" + input: "gradients_5/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients_5/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_5/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients_5/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_5/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/filter_type_1/Slice_2_grad/sub_1" + input: "gradients_5/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_5/filter_type_1/Slice_2_grad/Reshape" + input: "gradients_5/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients_5/filter_type_1/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 + } + } +} +node { + name: "gradients_5/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_5/AddN_17" + input: "gradients_5/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_18" + op: "AddN" + input: "gradients_5/filter_type_0/Slice_grad/Pad" + input: "gradients_5/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_5/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_5/AddN_18" + input: "gradients_5/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_19" + op: "AddN" + input: "gradients_5/filter_type_1/Slice_grad/Pad" + input: "gradients_5/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_5/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_5/AddN_19" + input: "gradients_5/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/Slice_grad/stack" + op: "Pack" + input: "gradients_5/Slice_grad/Rank" + input: "gradients_5/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients_5/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_grad/sub" + op: "Sub" + input: "gradients_5/Slice_grad/Shape_1" + input: "gradients_5/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_grad/sub_1" + op: "Sub" + input: "gradients_5/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/Slice_grad/sub_1" + input: "gradients_5/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_5/Slice_grad/Reshape" + input: "gradients_5/Slice_grad/Reshape_1" + input: "gradients_5/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_grad/Pad" + op: "Pad" + input: "gradients_5/Reshape_5_grad/Reshape" + input: "gradients_5/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_5/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/Slice_1_grad/stack" + op: "Pack" + input: "gradients_5/Slice_1_grad/Rank" + input: "gradients_5/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_5/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients_5/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_1_grad/sub" + op: "Sub" + input: "gradients_5/Slice_1_grad/Shape_1" + input: "gradients_5/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_5/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_5/Slice_1_grad/sub_1" + input: "gradients_5/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_5/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_5/Slice_1_grad/Reshape" + input: "gradients_5/Slice_1_grad/Reshape_1" + input: "gradients_5/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 + } + } +} +node { + name: "gradients_5/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_5/Reshape_9_grad/Reshape" + input: "gradients_5/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/AddN_20" + op: "AddN" + input: "gradients_5/Slice_grad/Pad" + input: "gradients_5/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_5/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_5/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_5/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_5/AddN_20" + input: "gradients_5/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_49/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_49/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_49/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_49" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_49/stack" + input: "strided_slice_49/stack_1" + input: "strided_slice_49/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_38/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_38" + op: "Mul" + input: "strided_slice_49" + input: "mul_38/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_43/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_43/shape" + op: "Pack" + input: "Reshape_43/shape/0" + input: "mul_38" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_43" + op: "Reshape" + input: "gradients_5/Reshape_4_grad/Reshape" + input: "Reshape_43/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA_5" + op: "ProdForceSeA" + input: "Reshape_43" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA_5" + op: "ProdVirialSeA" + input: "Reshape_43" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_50/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_50/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_50/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_50" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_50/stack" + input: "strided_slice_50/stack_1" + input: "strided_slice_50/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_39/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_39" + op: "Mul" + input: "mul_39/x" + input: "strided_slice_50" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_44/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_44/shape" + op: "Pack" + input: "Reshape_44/shape/0" + input: "mul_39" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_44" + op: "Reshape" + input: "ProdForceSeA_5" + input: "Reshape_44/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_45/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_45" + op: "Reshape" + input: "ProdVirialSeA_5" + input: "Reshape_45/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_51/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_51/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_51/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_51" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_51/stack" + input: "strided_slice_51/stack_1" + input: "strided_slice_51/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_40/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_40" + op: "Mul" + input: "mul_40/x" + input: "strided_slice_51" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_46/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_46/shape" + op: "Pack" + input: "Reshape_46/shape/0" + input: "mul_40" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_46" + op: "Reshape" + input: "ProdVirialSeA_5:1" + input: "Reshape_46/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Shape" + op: "Shape" + input: "split:6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients_6/grad_ys_0" + op: "Fill" + input: "gradients_6/Shape" + input: "gradients_6/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/zeros_like" + op: "ZerosLike" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/zeros_like_1" + op: "ZerosLike" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/zeros_like_2" + op: "ZerosLike" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/zeros_like_3" + op: "ZerosLike" + input: "split:3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/zeros_like_4" + op: "ZerosLike" + input: "split:4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/zeros_like_5" + op: "ZerosLike" + input: "split:5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/zeros_like_6" + op: "ZerosLike" + input: "split:7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/zeros_like_7" + op: "ZerosLike" + input: "split:8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/split_grad/concat" + op: "ConcatV2" + input: "gradients_6/zeros_like" + input: "gradients_6/zeros_like_1" + input: "gradients_6/zeros_like_2" + input: "gradients_6/zeros_like_3" + input: "gradients_6/zeros_like_4" + input: "gradients_6/zeros_like_5" + input: "gradients_6/grad_ys_0" + input: "gradients_6/zeros_like_6" + input: "gradients_6/zeros_like_7" + input: "split/split_dim" + attr { + key: "N" + value { + i: 9 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_22_grad/Shape" + op: "Shape" + input: "o_polar" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients_6/split_grad/concat" + input: "gradients_6/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/o_polar_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/o_polar_grad/Reshape" + op: "Reshape" + input: "gradients_6/Reshape_22_grad/Reshape" + input: "gradients_6/o_polar_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_21_grad/Shape" + op: "Shape" + input: "add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients_6/o_polar_grad/Reshape" + input: "gradients_6/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_7_grad/Shape" + op: "Shape" + input: "mul_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_7_grad/Shape_1" + op: "Shape" + input: "mul_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/add_7_grad/Shape" + input: "gradients_6/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_7_grad/Sum" + op: "Sum" + input: "gradients_6/Reshape_21_grad/Reshape" + input: "gradients_6/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_6/add_7_grad/Sum" + input: "gradients_6/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/mul_16_grad/Shape" + op: "Shape" + input: "Reshape_18" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/mul_16_grad/Shape_1" + op: "Shape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/mul_16_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/mul_16_grad/Shape" + input: "gradients_6/mul_16_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/mul_16_grad/Mul" + op: "Mul" + input: "gradients_6/add_7_grad/Reshape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/mul_16_grad/Sum" + op: "Sum" + input: "gradients_6/mul_16_grad/Mul" + input: "gradients_6/mul_16_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/mul_16_grad/Reshape" + op: "Reshape" + input: "gradients_6/mul_16_grad/Sum" + input: "gradients_6/mul_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients_6/mul_16_grad/Reshape" + input: "gradients_6/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/MatMul_1_grad/MatMul" + op: "BatchMatMulV2" + input: "MatMul" + input: "gradients_6/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_6/MatMul_1_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_16" + input: "gradients_6/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_6/MatMul_1_grad/Shape" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/MatMul_1_grad/Shape_1" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/MatMul_1_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/MatMul_1_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/MatMul_1_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/MatMul_1_grad/strided_slice" + op: "StridedSlice" + input: "gradients_6/MatMul_1_grad/Shape" + input: "gradients_6/MatMul_1_grad/strided_slice/stack" + input: "gradients_6/MatMul_1_grad/strided_slice/stack_1" + input: "gradients_6/MatMul_1_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/MatMul_1_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/MatMul_1_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/MatMul_1_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/MatMul_1_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_6/MatMul_1_grad/Shape_1" + input: "gradients_6/MatMul_1_grad/strided_slice_1/stack" + input: "gradients_6/MatMul_1_grad/strided_slice_1/stack_1" + input: "gradients_6/MatMul_1_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/MatMul_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/MatMul_1_grad/strided_slice" + input: "gradients_6/MatMul_1_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/MatMul_1_grad/Sum" + op: "Sum" + input: "gradients_6/MatMul_1_grad/MatMul" + input: "gradients_6/MatMul_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/MatMul_1_grad/Reshape" + op: "Reshape" + input: "gradients_6/MatMul_1_grad/Sum" + input: "gradients_6/MatMul_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/MatMul_1_grad/Sum_1" + op: "Sum" + input: "gradients_6/MatMul_1_grad/MatMul_1" + input: "gradients_6/MatMul_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/MatMul_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/MatMul_1_grad/Sum_1" + input: "gradients_6/MatMul_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients_6/MatMul_1_grad/Reshape_1" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_6/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "add_6" + input: "gradients_6/MatMul_1_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_6/MatMul_grad/Shape" + op: "Shape" + input: "add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients_6/MatMul_grad/Shape" + input: "gradients_6/MatMul_grad/strided_slice/stack" + input: "gradients_6/MatMul_grad/strided_slice/stack_1" + input: "gradients_6/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_6/MatMul_grad/Shape_1" + input: "gradients_6/MatMul_grad/strided_slice_1/stack" + input: "gradients_6/MatMul_grad/strided_slice_1/stack_1" + input: "gradients_6/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/MatMul_grad/strided_slice" + input: "gradients_6/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/MatMul_grad/Sum" + op: "Sum" + input: "gradients_6/MatMul_grad/MatMul" + input: "gradients_6/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients_6/MatMul_grad/Sum" + input: "gradients_6/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients_6/MatMul_grad/MatMul_1" + input: "gradients_6/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/MatMul_grad/Sum_1" + input: "gradients_6/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_6_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_6_grad/Shape_1" + op: "Shape" + input: "transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/add_6_grad/Shape" + input: "gradients_6/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_6_grad/Sum" + op: "Sum" + input: "gradients_6/MatMul_grad/Reshape" + input: "gradients_6/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_6/add_6_grad/Sum" + input: "gradients_6/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_6_grad/Sum_1" + op: "Sum" + input: "gradients_6/MatMul_grad/Reshape" + input: "gradients_6/add_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/add_6_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/add_6_grad/Sum_1" + input: "gradients_6/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN" + op: "AddN" + input: "gradients_6/MatMul_1_grad/Reshape" + input: "gradients_6/MatMul_grad/Reshape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/MatMul_1_grad/Reshape" + } + } + } +} +node { + name: "gradients_6/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients_6/AddN" + input: "gradients_6/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/transpose_grad/transpose" + op: "Transpose" + input: "gradients_6/add_6_grad/Reshape_1" + input: "gradients_6/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/Slice_3_grad/stack" + op: "Pack" + input: "gradients_6/Slice_3_grad/Rank" + input: "gradients_6/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients_6/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_3_grad/sub" + op: "Sub" + input: "gradients_6/Slice_3_grad/Shape_1" + input: "gradients_6/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_6/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/Slice_3_grad/sub_1" + input: "gradients_6/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_6/Slice_3_grad/Reshape" + input: "gradients_6/Slice_3_grad/Reshape_1" + input: "gradients_6/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 + } + } +} +node { + name: "gradients_6/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_6/Reshape_16_grad/Reshape" + input: "gradients_6/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_1" + op: "AddN" + input: "gradients_6/add_6_grad/Reshape" + input: "gradients_6/transpose_grad/transpose" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/add_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_6/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients_6/AddN_1" + input: "gradients_6/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_6/Slice_3_grad/Pad" + input: "gradients_6/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/final_layer_type_0/add_grad/Shape" + input: "gradients_6/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_6/Reshape_17_grad/Reshape" + input: "gradients_6/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_6/final_layer_type_0/add_grad/Sum" + input: "gradients_6/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_6/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients_6/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_6/concat_1_grad/mod" + input: "gradients_6/concat_1_grad/ShapeN" + input: "gradients_6/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_6/concat_1_grad/Slice" + op: "Slice" + input: "gradients_6/Reshape_14_grad/Reshape" + input: "gradients_6/concat_1_grad/ConcatOffset" + input: "gradients_6/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_6/Reshape_14_grad/Reshape" + input: "gradients_6/concat_1_grad/ConcatOffset:1" + input: "gradients_6/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/add_5_grad/Shape" + op: "Shape" + input: "add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_5_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/add_5_grad/Shape" + input: "gradients_6/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_5_grad/Sum" + op: "Sum" + input: "gradients_6/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_6/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_6/add_5_grad/Sum" + input: "gradients_6/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_5_grad/Sum_1" + op: "Sum" + input: "gradients_6/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_6/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/add_5_grad/Sum_1" + input: "gradients_6/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_6/concat_1_grad/Slice" + input: "gradients_6/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_6/concat_1_grad/Slice_1" + input: "gradients_6/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/layer_2_type_0/mul_grad/Shape" + input: "gradients_6/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_6/add_5_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_6/layer_2_type_0/mul_grad/Mul" + input: "gradients_6/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_6/layer_2_type_0/mul_grad/Sum" + input: "gradients_6/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients_6/Reshape_8_grad/Reshape" + input: "gradients_6/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients_6/Reshape_12_grad/Reshape" + input: "gradients_6/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_6/layer_2_type_0/mul_grad/Reshape" + input: "gradients_6/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients_6/filter_type_0/Slice_5_grad/Rank" + input: "gradients_6/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients_6/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients_6/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients_6/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_6/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_0/Slice_5_grad/sub_1" + input: "gradients_6/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_6/filter_type_0/Slice_5_grad/Reshape" + input: "gradients_6/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients_6/filter_type_0/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 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_6/filter_type_0/transpose_grad/transpose" + input: "gradients_6/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients_6/filter_type_1/Slice_5_grad/Rank" + input: "gradients_6/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients_6/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients_6/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients_6/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_6/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_1/Slice_5_grad/sub_1" + input: "gradients_6/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_6/filter_type_1/Slice_5_grad/Reshape" + input: "gradients_6/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients_6/filter_type_1/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 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_6/filter_type_1/transpose_grad/transpose" + input: "gradients_6/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients_6/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/layer_2_type_0/add_grad/Shape" + input: "gradients_6/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_6/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients_6/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_6/layer_2_type_0/add_grad/Sum" + input: "gradients_6/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_6/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/AddN_2" + op: "AddN" + input: "gradients_6/add_5_grad/Reshape" + input: "gradients_6/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients_6/add_4_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_4_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/add_4_grad/Shape" + input: "gradients_6/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_4_grad/Sum" + op: "Sum" + input: "gradients_6/AddN_2" + input: "gradients_6/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_6/add_4_grad/Sum" + input: "gradients_6/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_6/AddN_2" + input: "gradients_6/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/add_4_grad/Sum_1" + input: "gradients_6/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/layer_1_type_0/mul_grad/Shape" + input: "gradients_6/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_6/add_4_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_6/layer_1_type_0/mul_grad/Mul" + input: "gradients_6/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_6/layer_1_type_0/mul_grad/Sum" + input: "gradients_6/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_6/layer_1_type_0/mul_grad/Reshape" + input: "gradients_6/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients_6/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/layer_1_type_0/add_grad/Shape" + input: "gradients_6/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_6/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients_6/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_6/layer_1_type_0/add_grad/Sum" + input: "gradients_6/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_6/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/AddN_3" + op: "AddN" + input: "gradients_6/add_4_grad/Reshape" + input: "gradients_6/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_6/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_6/AddN_3" + input: "gradients_6/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients_6/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/layer_0_type_0/add_grad/Shape" + input: "gradients_6/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_6/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients_6/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_6/layer_0_type_0/add_grad/Sum" + input: "gradients_6/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_6/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients_6/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients_6/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/Slice_2_grad/stack" + op: "Pack" + input: "gradients_6/Slice_2_grad/Rank" + input: "gradients_6/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients_6/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_2_grad/sub" + op: "Sub" + input: "gradients_6/Slice_2_grad/Shape_1" + input: "gradients_6/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_6/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/Slice_2_grad/sub_1" + input: "gradients_6/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_6/Slice_2_grad/Reshape" + input: "gradients_6/Slice_2_grad/Reshape_1" + input: "gradients_6/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 + } + } +} +node { + name: "gradients_6/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_6/Reshape_15_grad/Reshape" + input: "gradients_6/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_6/Slice_2_grad/Pad" + input: "gradients_6/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients_6/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_6/concat_grad/mod" + input: "gradients_6/concat_grad/ShapeN" + input: "gradients_6/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_6/concat_grad/Slice" + op: "Slice" + input: "gradients_6/Reshape_13_grad/Reshape" + input: "gradients_6/concat_grad/ConcatOffset" + input: "gradients_6/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/concat_grad/Slice_1" + op: "Slice" + input: "gradients_6/Reshape_13_grad/Reshape" + input: "gradients_6/concat_grad/ConcatOffset:1" + input: "gradients_6/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_6/concat_grad/Slice" + input: "gradients_6/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_6/concat_grad/Slice_1" + input: "gradients_6/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_6/Reshape_7_grad/Reshape" + input: "gradients_6/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_6/Reshape_11_grad/Reshape" + input: "gradients_6/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients_6/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients_6/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_6/filter_type_0/MatMul_8_grad/Shape" + input: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_6/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients_6/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients_6/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/MatMul_8_grad/Sum" + input: "gradients_6/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_6/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients_6/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients_6/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients_6/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients_6/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_6/filter_type_1/MatMul_8_grad/Shape" + input: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_6/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients_6/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients_6/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/MatMul_8_grad/Sum" + input: "gradients_6/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_6/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients_6/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients_6/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients_6/filter_type_0/Slice_4_grad/Rank" + input: "gradients_6/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients_6/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients_6/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients_6/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_6/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_0/Slice_4_grad/sub_1" + input: "gradients_6/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_6/filter_type_0/Slice_4_grad/Reshape" + input: "gradients_6/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients_6/filter_type_0/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 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_6/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients_6/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients_6/filter_type_1/Slice_4_grad/Rank" + input: "gradients_6/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients_6/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients_6/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients_6/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_6/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_1/Slice_4_grad/sub_1" + input: "gradients_6/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_6/filter_type_1/Slice_4_grad/Reshape" + input: "gradients_6/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients_6/filter_type_1/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 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_6/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients_6/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_4" + op: "AddN" + input: "gradients_6/filter_type_0/Slice_5_grad/Pad" + input: "gradients_6/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients_6/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_6/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/mul_grad/Shape" + input: "gradients_6/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_6/AddN_4" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_0/mul_grad/Mul" + input: "gradients_6/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/mul_grad/Sum" + input: "gradients_6/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_5" + op: "AddN" + input: "gradients_6/filter_type_1/Slice_5_grad/Pad" + input: "gradients_6/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients_6/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_6/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/mul_grad/Shape" + input: "gradients_6/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_6/AddN_5" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_1/mul_grad/Mul" + input: "gradients_6/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/mul_grad/Sum" + input: "gradients_6/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/add_10_grad/Shape" + input: "gradients_6/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_0/mul_grad/Reshape" + input: "gradients_6/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_10_grad/Sum" + input: "gradients_6/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_6/filter_type_0/mul_grad/Reshape" + input: "gradients_6/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_0/add_10_grad/Sum_1" + input: "gradients_6/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/add_10_grad/Shape" + input: "gradients_6/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_1/mul_grad/Reshape" + input: "gradients_6/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_10_grad/Sum" + input: "gradients_6/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_6/filter_type_1/mul_grad/Reshape" + input: "gradients_6/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_1/add_10_grad/Sum_1" + input: "gradients_6/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients_6/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients_6/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_6/filter_type_0/MatMul_3_grad/Shape" + input: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_6/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients_6/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients_6/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/MatMul_3_grad/Sum" + input: "gradients_6/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_6/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients_6/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients_6/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients_6/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients_6/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_6/filter_type_0/MatMul_7_grad/Shape" + input: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_6/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients_6/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients_6/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/MatMul_7_grad/Sum" + input: "gradients_6/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_6/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients_6/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients_6/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients_6/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients_6/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_6/filter_type_1/MatMul_3_grad/Shape" + input: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_6/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients_6/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients_6/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/MatMul_3_grad/Sum" + input: "gradients_6/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_6/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients_6/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients_6/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients_6/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients_6/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_6/filter_type_1/MatMul_7_grad/Shape" + input: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_6/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_6/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients_6/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients_6/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/MatMul_7_grad/Sum" + input: "gradients_6/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_6/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients_6/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients_6/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients_6/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients_6/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients_6/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients_6/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients_6/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients_6/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients_6/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients_6/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/add_4_grad/Shape" + input: "gradients_6/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_6/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_4_grad/Sum" + input: "gradients_6/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_6/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_6/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_0/add_4_grad/Sum_1" + input: "gradients_6/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/add_9_grad/Shape" + input: "gradients_6/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_6/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_9_grad/Sum" + input: "gradients_6/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_6/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_6/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_0/add_9_grad/Sum_1" + input: "gradients_6/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/add_4_grad/Shape" + input: "gradients_6/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_6/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_4_grad/Sum" + input: "gradients_6/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_6/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_6/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_1/add_4_grad/Sum_1" + input: "gradients_6/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/add_9_grad/Shape" + input: "gradients_6/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_6/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_9_grad/Sum" + input: "gradients_6/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_6/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_6/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_1/add_9_grad/Sum_1" + input: "gradients_6/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_0/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_1/axis" + input: "gradients_6/filter_type_0/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_2" + input: "filter_type_0/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_6/filter_type_0/concat_1_grad/mod" + input: "gradients_6/filter_type_0/concat_1_grad/ShapeN" + input: "gradients_6/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_1_grad/Slice" + op: "Slice" + input: "gradients_6/filter_type_0/add_4_grad/Reshape" + input: "gradients_6/filter_type_0/concat_1_grad/ConcatOffset" + input: "gradients_6/filter_type_0/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_6/filter_type_0/add_4_grad/Reshape" + input: "gradients_6/filter_type_0/concat_1_grad/ConcatOffset:1" + input: "gradients_6/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_4_grad/Reshape_1" + input: "gradients_6/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_0/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_3/axis" + input: "gradients_6/filter_type_0/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_7" + input: "filter_type_0/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_6/filter_type_0/concat_3_grad/mod" + input: "gradients_6/filter_type_0/concat_3_grad/ShapeN" + input: "gradients_6/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_3_grad/Slice" + op: "Slice" + input: "gradients_6/filter_type_0/add_9_grad/Reshape" + input: "gradients_6/filter_type_0/concat_3_grad/ConcatOffset" + input: "gradients_6/filter_type_0/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_6/filter_type_0/add_9_grad/Reshape" + input: "gradients_6/filter_type_0/concat_3_grad/ConcatOffset:1" + input: "gradients_6/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_9_grad/Reshape_1" + input: "gradients_6/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_1/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_1/axis" + input: "gradients_6/filter_type_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_2" + input: "filter_type_1/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_6/filter_type_1/concat_1_grad/mod" + input: "gradients_6/filter_type_1/concat_1_grad/ShapeN" + input: "gradients_6/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients_6/filter_type_1/add_4_grad/Reshape" + input: "gradients_6/filter_type_1/concat_1_grad/ConcatOffset" + input: "gradients_6/filter_type_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_6/filter_type_1/add_4_grad/Reshape" + input: "gradients_6/filter_type_1/concat_1_grad/ConcatOffset:1" + input: "gradients_6/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_4_grad/Reshape_1" + input: "gradients_6/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_1/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_3/axis" + input: "gradients_6/filter_type_1/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_7" + input: "filter_type_1/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_6/filter_type_1/concat_3_grad/mod" + input: "gradients_6/filter_type_1/concat_3_grad/ShapeN" + input: "gradients_6/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_3_grad/Slice" + op: "Slice" + input: "gradients_6/filter_type_1/add_9_grad/Reshape" + input: "gradients_6/filter_type_1/concat_3_grad/ConcatOffset" + input: "gradients_6/filter_type_1/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_6/filter_type_1/add_9_grad/Reshape" + input: "gradients_6/filter_type_1/concat_3_grad/ConcatOffset:1" + input: "gradients_6/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_9_grad/Reshape_1" + input: "gradients_6/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients_6/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients_6/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients_6/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients_6/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/add_3_grad/Shape" + input: "gradients_6/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients_6/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_3_grad/Sum" + input: "gradients_6/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/add_8_grad/Shape" + input: "gradients_6/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients_6/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_8_grad/Sum" + input: "gradients_6/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/add_3_grad/Shape" + input: "gradients_6/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients_6/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_3_grad/Sum" + input: "gradients_6/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/add_8_grad/Shape" + input: "gradients_6/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients_6/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_8_grad/Sum" + input: "gradients_6/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_6/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_6/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_6/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_6/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/AddN_6" + op: "AddN" + input: "gradients_6/filter_type_0/concat_1_grad/Slice" + input: "gradients_6/filter_type_0/concat_1_grad/Slice_1" + input: "gradients_6/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_0/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_6/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/add_2_grad/Shape" + input: "gradients_6/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients_6/AddN_6" + input: "gradients_6/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_2_grad/Sum" + input: "gradients_6/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_6/AddN_6" + input: "gradients_6/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_0/add_2_grad/Sum_1" + input: "gradients_6/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_7" + op: "AddN" + input: "gradients_6/filter_type_0/concat_3_grad/Slice" + input: "gradients_6/filter_type_0/concat_3_grad/Slice_1" + input: "gradients_6/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_0/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_6/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/add_7_grad/Shape" + input: "gradients_6/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients_6/AddN_7" + input: "gradients_6/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_7_grad/Sum" + input: "gradients_6/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_6/AddN_7" + input: "gradients_6/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_0/add_7_grad/Sum_1" + input: "gradients_6/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_8" + op: "AddN" + input: "gradients_6/filter_type_1/concat_1_grad/Slice" + input: "gradients_6/filter_type_1/concat_1_grad/Slice_1" + input: "gradients_6/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_1/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_6/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/add_2_grad/Shape" + input: "gradients_6/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients_6/AddN_8" + input: "gradients_6/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_2_grad/Sum" + input: "gradients_6/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_6/AddN_8" + input: "gradients_6/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_1/add_2_grad/Sum_1" + input: "gradients_6/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_9" + op: "AddN" + input: "gradients_6/filter_type_1/concat_3_grad/Slice" + input: "gradients_6/filter_type_1/concat_3_grad/Slice_1" + input: "gradients_6/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_1/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_6/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/add_7_grad/Shape" + input: "gradients_6/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients_6/AddN_9" + input: "gradients_6/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_7_grad/Sum" + input: "gradients_6/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_6/AddN_9" + input: "gradients_6/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_1/add_7_grad/Sum_1" + input: "gradients_6/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_0/concat_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat/axis" + input: "gradients_6/filter_type_0/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_6/filter_type_0/concat_grad/mod" + input: "gradients_6/filter_type_0/concat_grad/ShapeN" + input: "gradients_6/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_grad/Slice" + op: "Slice" + input: "gradients_6/filter_type_0/add_2_grad/Reshape" + input: "gradients_6/filter_type_0/concat_grad/ConcatOffset" + input: "gradients_6/filter_type_0/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/concat_grad/Slice_1" + op: "Slice" + input: "gradients_6/filter_type_0/add_2_grad/Reshape" + input: "gradients_6/filter_type_0/concat_grad/ConcatOffset:1" + input: "gradients_6/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_2_grad/Reshape_1" + input: "gradients_6/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_0/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_2/axis" + input: "gradients_6/filter_type_0/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_6/filter_type_0/concat_2_grad/mod" + input: "gradients_6/filter_type_0/concat_2_grad/ShapeN" + input: "gradients_6/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_6/filter_type_0/concat_2_grad/Slice" + op: "Slice" + input: "gradients_6/filter_type_0/add_7_grad/Reshape" + input: "gradients_6/filter_type_0/concat_2_grad/ConcatOffset" + input: "gradients_6/filter_type_0/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_6/filter_type_0/add_7_grad/Reshape" + input: "gradients_6/filter_type_0/concat_2_grad/ConcatOffset:1" + input: "gradients_6/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_7_grad/Reshape_1" + input: "gradients_6/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_1/concat_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat/axis" + input: "gradients_6/filter_type_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_6/filter_type_1/concat_grad/mod" + input: "gradients_6/filter_type_1/concat_grad/ShapeN" + input: "gradients_6/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_grad/Slice" + op: "Slice" + input: "gradients_6/filter_type_1/add_2_grad/Reshape" + input: "gradients_6/filter_type_1/concat_grad/ConcatOffset" + input: "gradients_6/filter_type_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients_6/filter_type_1/add_2_grad/Reshape" + input: "gradients_6/filter_type_1/concat_grad/ConcatOffset:1" + input: "gradients_6/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_2_grad/Reshape_1" + input: "gradients_6/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_1/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_2/axis" + input: "gradients_6/filter_type_1/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_6/filter_type_1/concat_2_grad/mod" + input: "gradients_6/filter_type_1/concat_2_grad/ShapeN" + input: "gradients_6/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_6/filter_type_1/concat_2_grad/Slice" + op: "Slice" + input: "gradients_6/filter_type_1/add_7_grad/Reshape" + input: "gradients_6/filter_type_1/concat_2_grad/ConcatOffset" + input: "gradients_6/filter_type_1/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_6/filter_type_1/add_7_grad/Reshape" + input: "gradients_6/filter_type_1/concat_2_grad/ConcatOffset:1" + input: "gradients_6/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_7_grad/Reshape_1" + input: "gradients_6/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients_6/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients_6/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients_6/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients_6/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/add_1_grad/Shape" + input: "gradients_6/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients_6/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_1_grad/Sum" + input: "gradients_6/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/add_6_grad/Shape" + input: "gradients_6/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients_6/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_6_grad/Sum" + input: "gradients_6/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/add_1_grad/Shape" + input: "gradients_6/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients_6/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_1_grad/Sum" + input: "gradients_6/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/add_6_grad/Shape" + input: "gradients_6/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients_6/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_6_grad/Sum" + input: "gradients_6/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_6/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_6/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_6/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_6/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/AddN_10" + op: "AddN" + input: "gradients_6/filter_type_0/concat_grad/Slice" + input: "gradients_6/filter_type_0/concat_grad/Slice_1" + input: "gradients_6/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_0/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_6/AddN_10" + input: "gradients_6/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_11" + op: "AddN" + input: "gradients_6/filter_type_0/concat_2_grad/Slice" + input: "gradients_6/filter_type_0/concat_2_grad/Slice_1" + input: "gradients_6/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_0/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_6/AddN_11" + input: "gradients_6/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_12" + op: "AddN" + input: "gradients_6/filter_type_1/concat_grad/Slice" + input: "gradients_6/filter_type_1/concat_grad/Slice_1" + input: "gradients_6/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_1/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_6/AddN_12" + input: "gradients_6/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_13" + op: "AddN" + input: "gradients_6/filter_type_1/concat_2_grad/Slice" + input: "gradients_6/filter_type_1/concat_2_grad/Slice_1" + input: "gradients_6/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_1/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_6/AddN_13" + input: "gradients_6/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients_6/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients_6/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients_6/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients_6/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_6/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/add_grad/Shape" + input: "gradients_6/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients_6/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_grad/Sum" + input: "gradients_6/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_0/add_5_grad/Shape" + input: "gradients_6/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients_6/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/add_5_grad/Sum" + input: "gradients_6/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/add_grad/Shape" + input: "gradients_6/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients_6/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_grad/Sum" + input: "gradients_6/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_6/filter_type_1/add_5_grad/Shape" + input: "gradients_6/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_6/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients_6/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_6/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/add_5_grad/Sum" + input: "gradients_6/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_6/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_6/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_6/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_6/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/MatMul_grad/MatMul" + input: "gradients_6/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients_6/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/MatMul_grad/MatMul" + input: "gradients_6/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients_6/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients_6/filter_type_0/Slice_1_grad/Rank" + input: "gradients_6/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients_6/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients_6/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients_6/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_6/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_0/Slice_1_grad/sub_1" + input: "gradients_6/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_6/filter_type_0/Slice_1_grad/Reshape" + input: "gradients_6/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients_6/filter_type_0/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 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_6/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients_6/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients_6/filter_type_0/Slice_3_grad/Rank" + input: "gradients_6/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients_6/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients_6/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients_6/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_6/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_0/Slice_3_grad/sub_1" + input: "gradients_6/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_6/filter_type_0/Slice_3_grad/Reshape" + input: "gradients_6/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients_6/filter_type_0/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 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_6/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients_6/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_6/filter_type_1/Slice_1_grad/Rank" + input: "gradients_6/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients_6/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_6/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients_6/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_6/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_1/Slice_1_grad/sub_1" + input: "gradients_6/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_6/filter_type_1/Slice_1_grad/Reshape" + input: "gradients_6/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients_6/filter_type_1/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 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_6/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients_6/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_6/filter_type_1/Slice_3_grad/Rank" + input: "gradients_6/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients_6/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_6/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients_6/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_6/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_1/Slice_3_grad/sub_1" + input: "gradients_6/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_6/filter_type_1/Slice_3_grad/Reshape" + input: "gradients_6/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients_6/filter_type_1/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 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_6/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients_6/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/Slice_1_grad/Pad" + input: "gradients_6/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_0/Slice_3_grad/Pad" + input: "gradients_6/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/Slice_1_grad/Pad" + input: "gradients_6/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_6/filter_type_1/Slice_3_grad/Pad" + input: "gradients_6/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_14" + op: "AddN" + input: "gradients_6/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients_6/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients_6/filter_type_0/Slice_grad/Rank" + input: "gradients_6/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients_6/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients_6/filter_type_0/Slice_grad/Shape_1" + input: "gradients_6/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients_6/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_0/Slice_grad/sub_1" + input: "gradients_6/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_6/filter_type_0/Slice_grad/Reshape" + input: "gradients_6/filter_type_0/Slice_grad/Reshape_1" + input: "gradients_6/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients_6/AddN_14" + input: "gradients_6/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_15" + op: "AddN" + input: "gradients_6/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients_6/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients_6/filter_type_0/Slice_2_grad/Rank" + input: "gradients_6/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients_6/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients_6/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients_6/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_6/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_0/Slice_2_grad/sub_1" + input: "gradients_6/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_6/filter_type_0/Slice_2_grad/Reshape" + input: "gradients_6/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients_6/filter_type_0/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 + } + } +} +node { + name: "gradients_6/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_6/AddN_15" + input: "gradients_6/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_16" + op: "AddN" + input: "gradients_6/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients_6/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients_6/filter_type_1/Slice_grad/Rank" + input: "gradients_6/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients_6/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients_6/filter_type_1/Slice_grad/Shape_1" + input: "gradients_6/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_6/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_1/Slice_grad/sub_1" + input: "gradients_6/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_6/filter_type_1/Slice_grad/Reshape" + input: "gradients_6/filter_type_1/Slice_grad/Reshape_1" + input: "gradients_6/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_6/AddN_16" + input: "gradients_6/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_17" + op: "AddN" + input: "gradients_6/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients_6/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_6/filter_type_1/Slice_2_grad/Rank" + input: "gradients_6/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients_6/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_6/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients_6/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_6/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/filter_type_1/Slice_2_grad/sub_1" + input: "gradients_6/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_6/filter_type_1/Slice_2_grad/Reshape" + input: "gradients_6/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients_6/filter_type_1/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 + } + } +} +node { + name: "gradients_6/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_6/AddN_17" + input: "gradients_6/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_18" + op: "AddN" + input: "gradients_6/filter_type_0/Slice_grad/Pad" + input: "gradients_6/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_6/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_6/AddN_18" + input: "gradients_6/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_19" + op: "AddN" + input: "gradients_6/filter_type_1/Slice_grad/Pad" + input: "gradients_6/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_6/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_6/AddN_19" + input: "gradients_6/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/Slice_grad/stack" + op: "Pack" + input: "gradients_6/Slice_grad/Rank" + input: "gradients_6/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients_6/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_grad/sub" + op: "Sub" + input: "gradients_6/Slice_grad/Shape_1" + input: "gradients_6/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_grad/sub_1" + op: "Sub" + input: "gradients_6/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/Slice_grad/sub_1" + input: "gradients_6/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_6/Slice_grad/Reshape" + input: "gradients_6/Slice_grad/Reshape_1" + input: "gradients_6/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_grad/Pad" + op: "Pad" + input: "gradients_6/Reshape_5_grad/Reshape" + input: "gradients_6/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_6/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/Slice_1_grad/stack" + op: "Pack" + input: "gradients_6/Slice_1_grad/Rank" + input: "gradients_6/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_6/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients_6/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_1_grad/sub" + op: "Sub" + input: "gradients_6/Slice_1_grad/Shape_1" + input: "gradients_6/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_6/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_6/Slice_1_grad/sub_1" + input: "gradients_6/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_6/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_6/Slice_1_grad/Reshape" + input: "gradients_6/Slice_1_grad/Reshape_1" + input: "gradients_6/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 + } + } +} +node { + name: "gradients_6/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_6/Reshape_9_grad/Reshape" + input: "gradients_6/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/AddN_20" + op: "AddN" + input: "gradients_6/Slice_grad/Pad" + input: "gradients_6/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_6/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_6/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_6/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_6/AddN_20" + input: "gradients_6/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_52/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_52/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_52/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_52" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_52/stack" + input: "strided_slice_52/stack_1" + input: "strided_slice_52/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_41/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_41" + op: "Mul" + input: "strided_slice_52" + input: "mul_41/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_47/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_47/shape" + op: "Pack" + input: "Reshape_47/shape/0" + input: "mul_41" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_47" + op: "Reshape" + input: "gradients_6/Reshape_4_grad/Reshape" + input: "Reshape_47/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA_6" + op: "ProdForceSeA" + input: "Reshape_47" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA_6" + op: "ProdVirialSeA" + input: "Reshape_47" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_53/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_53/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_53/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_53" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_53/stack" + input: "strided_slice_53/stack_1" + input: "strided_slice_53/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_42/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_42" + op: "Mul" + input: "mul_42/x" + input: "strided_slice_53" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_48/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_48/shape" + op: "Pack" + input: "Reshape_48/shape/0" + input: "mul_42" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_48" + op: "Reshape" + input: "ProdForceSeA_6" + input: "Reshape_48/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_49/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_49" + op: "Reshape" + input: "ProdVirialSeA_6" + input: "Reshape_49/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_54/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_54/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_54/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_54" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_54/stack" + input: "strided_slice_54/stack_1" + input: "strided_slice_54/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_43/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_43" + op: "Mul" + input: "mul_43/x" + input: "strided_slice_54" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_50/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_50/shape" + op: "Pack" + input: "Reshape_50/shape/0" + input: "mul_43" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_50" + op: "Reshape" + input: "ProdVirialSeA_6:1" + input: "Reshape_50/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Shape" + op: "Shape" + input: "split:7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients_7/grad_ys_0" + op: "Fill" + input: "gradients_7/Shape" + input: "gradients_7/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/zeros_like" + op: "ZerosLike" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/zeros_like_1" + op: "ZerosLike" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/zeros_like_2" + op: "ZerosLike" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/zeros_like_3" + op: "ZerosLike" + input: "split:3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/zeros_like_4" + op: "ZerosLike" + input: "split:4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/zeros_like_5" + op: "ZerosLike" + input: "split:5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/zeros_like_6" + op: "ZerosLike" + input: "split:6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/zeros_like_7" + op: "ZerosLike" + input: "split:8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/split_grad/concat" + op: "ConcatV2" + input: "gradients_7/zeros_like" + input: "gradients_7/zeros_like_1" + input: "gradients_7/zeros_like_2" + input: "gradients_7/zeros_like_3" + input: "gradients_7/zeros_like_4" + input: "gradients_7/zeros_like_5" + input: "gradients_7/zeros_like_6" + input: "gradients_7/grad_ys_0" + input: "gradients_7/zeros_like_7" + input: "split/split_dim" + attr { + key: "N" + value { + i: 9 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_22_grad/Shape" + op: "Shape" + input: "o_polar" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients_7/split_grad/concat" + input: "gradients_7/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/o_polar_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/o_polar_grad/Reshape" + op: "Reshape" + input: "gradients_7/Reshape_22_grad/Reshape" + input: "gradients_7/o_polar_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_21_grad/Shape" + op: "Shape" + input: "add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients_7/o_polar_grad/Reshape" + input: "gradients_7/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_7_grad/Shape" + op: "Shape" + input: "mul_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_7_grad/Shape_1" + op: "Shape" + input: "mul_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/add_7_grad/Shape" + input: "gradients_7/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_7_grad/Sum" + op: "Sum" + input: "gradients_7/Reshape_21_grad/Reshape" + input: "gradients_7/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_7/add_7_grad/Sum" + input: "gradients_7/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/mul_16_grad/Shape" + op: "Shape" + input: "Reshape_18" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/mul_16_grad/Shape_1" + op: "Shape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/mul_16_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/mul_16_grad/Shape" + input: "gradients_7/mul_16_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/mul_16_grad/Mul" + op: "Mul" + input: "gradients_7/add_7_grad/Reshape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/mul_16_grad/Sum" + op: "Sum" + input: "gradients_7/mul_16_grad/Mul" + input: "gradients_7/mul_16_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/mul_16_grad/Reshape" + op: "Reshape" + input: "gradients_7/mul_16_grad/Sum" + input: "gradients_7/mul_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients_7/mul_16_grad/Reshape" + input: "gradients_7/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/MatMul_1_grad/MatMul" + op: "BatchMatMulV2" + input: "MatMul" + input: "gradients_7/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_7/MatMul_1_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_16" + input: "gradients_7/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_7/MatMul_1_grad/Shape" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/MatMul_1_grad/Shape_1" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/MatMul_1_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/MatMul_1_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/MatMul_1_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/MatMul_1_grad/strided_slice" + op: "StridedSlice" + input: "gradients_7/MatMul_1_grad/Shape" + input: "gradients_7/MatMul_1_grad/strided_slice/stack" + input: "gradients_7/MatMul_1_grad/strided_slice/stack_1" + input: "gradients_7/MatMul_1_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/MatMul_1_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/MatMul_1_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/MatMul_1_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/MatMul_1_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_7/MatMul_1_grad/Shape_1" + input: "gradients_7/MatMul_1_grad/strided_slice_1/stack" + input: "gradients_7/MatMul_1_grad/strided_slice_1/stack_1" + input: "gradients_7/MatMul_1_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/MatMul_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/MatMul_1_grad/strided_slice" + input: "gradients_7/MatMul_1_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/MatMul_1_grad/Sum" + op: "Sum" + input: "gradients_7/MatMul_1_grad/MatMul" + input: "gradients_7/MatMul_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/MatMul_1_grad/Reshape" + op: "Reshape" + input: "gradients_7/MatMul_1_grad/Sum" + input: "gradients_7/MatMul_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/MatMul_1_grad/Sum_1" + op: "Sum" + input: "gradients_7/MatMul_1_grad/MatMul_1" + input: "gradients_7/MatMul_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/MatMul_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/MatMul_1_grad/Sum_1" + input: "gradients_7/MatMul_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients_7/MatMul_1_grad/Reshape_1" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_7/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "add_6" + input: "gradients_7/MatMul_1_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_7/MatMul_grad/Shape" + op: "Shape" + input: "add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients_7/MatMul_grad/Shape" + input: "gradients_7/MatMul_grad/strided_slice/stack" + input: "gradients_7/MatMul_grad/strided_slice/stack_1" + input: "gradients_7/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_7/MatMul_grad/Shape_1" + input: "gradients_7/MatMul_grad/strided_slice_1/stack" + input: "gradients_7/MatMul_grad/strided_slice_1/stack_1" + input: "gradients_7/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/MatMul_grad/strided_slice" + input: "gradients_7/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/MatMul_grad/Sum" + op: "Sum" + input: "gradients_7/MatMul_grad/MatMul" + input: "gradients_7/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients_7/MatMul_grad/Sum" + input: "gradients_7/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients_7/MatMul_grad/MatMul_1" + input: "gradients_7/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/MatMul_grad/Sum_1" + input: "gradients_7/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_6_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_6_grad/Shape_1" + op: "Shape" + input: "transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/add_6_grad/Shape" + input: "gradients_7/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_6_grad/Sum" + op: "Sum" + input: "gradients_7/MatMul_grad/Reshape" + input: "gradients_7/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_7/add_6_grad/Sum" + input: "gradients_7/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_6_grad/Sum_1" + op: "Sum" + input: "gradients_7/MatMul_grad/Reshape" + input: "gradients_7/add_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/add_6_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/add_6_grad/Sum_1" + input: "gradients_7/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN" + op: "AddN" + input: "gradients_7/MatMul_1_grad/Reshape" + input: "gradients_7/MatMul_grad/Reshape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/MatMul_1_grad/Reshape" + } + } + } +} +node { + name: "gradients_7/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients_7/AddN" + input: "gradients_7/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/transpose_grad/transpose" + op: "Transpose" + input: "gradients_7/add_6_grad/Reshape_1" + input: "gradients_7/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/Slice_3_grad/stack" + op: "Pack" + input: "gradients_7/Slice_3_grad/Rank" + input: "gradients_7/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients_7/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_3_grad/sub" + op: "Sub" + input: "gradients_7/Slice_3_grad/Shape_1" + input: "gradients_7/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_7/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/Slice_3_grad/sub_1" + input: "gradients_7/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_7/Slice_3_grad/Reshape" + input: "gradients_7/Slice_3_grad/Reshape_1" + input: "gradients_7/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 + } + } +} +node { + name: "gradients_7/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_7/Reshape_16_grad/Reshape" + input: "gradients_7/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_1" + op: "AddN" + input: "gradients_7/add_6_grad/Reshape" + input: "gradients_7/transpose_grad/transpose" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/add_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_7/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients_7/AddN_1" + input: "gradients_7/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_7/Slice_3_grad/Pad" + input: "gradients_7/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/final_layer_type_0/add_grad/Shape" + input: "gradients_7/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_7/Reshape_17_grad/Reshape" + input: "gradients_7/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_7/final_layer_type_0/add_grad/Sum" + input: "gradients_7/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_7/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients_7/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_7/concat_1_grad/mod" + input: "gradients_7/concat_1_grad/ShapeN" + input: "gradients_7/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_7/concat_1_grad/Slice" + op: "Slice" + input: "gradients_7/Reshape_14_grad/Reshape" + input: "gradients_7/concat_1_grad/ConcatOffset" + input: "gradients_7/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_7/Reshape_14_grad/Reshape" + input: "gradients_7/concat_1_grad/ConcatOffset:1" + input: "gradients_7/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/add_5_grad/Shape" + op: "Shape" + input: "add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_5_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/add_5_grad/Shape" + input: "gradients_7/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_5_grad/Sum" + op: "Sum" + input: "gradients_7/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_7/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_7/add_5_grad/Sum" + input: "gradients_7/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_5_grad/Sum_1" + op: "Sum" + input: "gradients_7/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_7/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/add_5_grad/Sum_1" + input: "gradients_7/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_7/concat_1_grad/Slice" + input: "gradients_7/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_7/concat_1_grad/Slice_1" + input: "gradients_7/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/layer_2_type_0/mul_grad/Shape" + input: "gradients_7/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_7/add_5_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_7/layer_2_type_0/mul_grad/Mul" + input: "gradients_7/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_7/layer_2_type_0/mul_grad/Sum" + input: "gradients_7/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients_7/Reshape_8_grad/Reshape" + input: "gradients_7/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients_7/Reshape_12_grad/Reshape" + input: "gradients_7/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_7/layer_2_type_0/mul_grad/Reshape" + input: "gradients_7/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients_7/filter_type_0/Slice_5_grad/Rank" + input: "gradients_7/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients_7/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients_7/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients_7/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_7/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_0/Slice_5_grad/sub_1" + input: "gradients_7/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_7/filter_type_0/Slice_5_grad/Reshape" + input: "gradients_7/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients_7/filter_type_0/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 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_7/filter_type_0/transpose_grad/transpose" + input: "gradients_7/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients_7/filter_type_1/Slice_5_grad/Rank" + input: "gradients_7/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients_7/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients_7/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients_7/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_7/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_1/Slice_5_grad/sub_1" + input: "gradients_7/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_7/filter_type_1/Slice_5_grad/Reshape" + input: "gradients_7/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients_7/filter_type_1/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 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_7/filter_type_1/transpose_grad/transpose" + input: "gradients_7/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients_7/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/layer_2_type_0/add_grad/Shape" + input: "gradients_7/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_7/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients_7/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_7/layer_2_type_0/add_grad/Sum" + input: "gradients_7/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_7/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/AddN_2" + op: "AddN" + input: "gradients_7/add_5_grad/Reshape" + input: "gradients_7/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients_7/add_4_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_4_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/add_4_grad/Shape" + input: "gradients_7/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_4_grad/Sum" + op: "Sum" + input: "gradients_7/AddN_2" + input: "gradients_7/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_7/add_4_grad/Sum" + input: "gradients_7/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_7/AddN_2" + input: "gradients_7/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/add_4_grad/Sum_1" + input: "gradients_7/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/layer_1_type_0/mul_grad/Shape" + input: "gradients_7/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_7/add_4_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_7/layer_1_type_0/mul_grad/Mul" + input: "gradients_7/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_7/layer_1_type_0/mul_grad/Sum" + input: "gradients_7/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_7/layer_1_type_0/mul_grad/Reshape" + input: "gradients_7/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients_7/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/layer_1_type_0/add_grad/Shape" + input: "gradients_7/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_7/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients_7/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_7/layer_1_type_0/add_grad/Sum" + input: "gradients_7/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_7/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/AddN_3" + op: "AddN" + input: "gradients_7/add_4_grad/Reshape" + input: "gradients_7/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_7/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_7/AddN_3" + input: "gradients_7/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients_7/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/layer_0_type_0/add_grad/Shape" + input: "gradients_7/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_7/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients_7/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_7/layer_0_type_0/add_grad/Sum" + input: "gradients_7/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_7/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients_7/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients_7/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/Slice_2_grad/stack" + op: "Pack" + input: "gradients_7/Slice_2_grad/Rank" + input: "gradients_7/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients_7/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_2_grad/sub" + op: "Sub" + input: "gradients_7/Slice_2_grad/Shape_1" + input: "gradients_7/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_7/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/Slice_2_grad/sub_1" + input: "gradients_7/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_7/Slice_2_grad/Reshape" + input: "gradients_7/Slice_2_grad/Reshape_1" + input: "gradients_7/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 + } + } +} +node { + name: "gradients_7/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_7/Reshape_15_grad/Reshape" + input: "gradients_7/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_7/Slice_2_grad/Pad" + input: "gradients_7/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients_7/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_7/concat_grad/mod" + input: "gradients_7/concat_grad/ShapeN" + input: "gradients_7/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_7/concat_grad/Slice" + op: "Slice" + input: "gradients_7/Reshape_13_grad/Reshape" + input: "gradients_7/concat_grad/ConcatOffset" + input: "gradients_7/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/concat_grad/Slice_1" + op: "Slice" + input: "gradients_7/Reshape_13_grad/Reshape" + input: "gradients_7/concat_grad/ConcatOffset:1" + input: "gradients_7/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_7/concat_grad/Slice" + input: "gradients_7/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_7/concat_grad/Slice_1" + input: "gradients_7/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_7/Reshape_7_grad/Reshape" + input: "gradients_7/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_7/Reshape_11_grad/Reshape" + input: "gradients_7/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients_7/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients_7/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_7/filter_type_0/MatMul_8_grad/Shape" + input: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_7/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients_7/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients_7/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/MatMul_8_grad/Sum" + input: "gradients_7/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_7/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients_7/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients_7/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients_7/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients_7/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_7/filter_type_1/MatMul_8_grad/Shape" + input: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_7/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients_7/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients_7/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/MatMul_8_grad/Sum" + input: "gradients_7/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_7/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients_7/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients_7/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients_7/filter_type_0/Slice_4_grad/Rank" + input: "gradients_7/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients_7/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients_7/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients_7/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_7/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_0/Slice_4_grad/sub_1" + input: "gradients_7/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_7/filter_type_0/Slice_4_grad/Reshape" + input: "gradients_7/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients_7/filter_type_0/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 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_7/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients_7/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients_7/filter_type_1/Slice_4_grad/Rank" + input: "gradients_7/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients_7/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients_7/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients_7/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_7/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_1/Slice_4_grad/sub_1" + input: "gradients_7/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_7/filter_type_1/Slice_4_grad/Reshape" + input: "gradients_7/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients_7/filter_type_1/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 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_7/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients_7/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_4" + op: "AddN" + input: "gradients_7/filter_type_0/Slice_5_grad/Pad" + input: "gradients_7/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients_7/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_7/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/mul_grad/Shape" + input: "gradients_7/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_7/AddN_4" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_0/mul_grad/Mul" + input: "gradients_7/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/mul_grad/Sum" + input: "gradients_7/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_5" + op: "AddN" + input: "gradients_7/filter_type_1/Slice_5_grad/Pad" + input: "gradients_7/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients_7/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_7/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/mul_grad/Shape" + input: "gradients_7/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_7/AddN_5" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_1/mul_grad/Mul" + input: "gradients_7/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/mul_grad/Sum" + input: "gradients_7/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/add_10_grad/Shape" + input: "gradients_7/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_0/mul_grad/Reshape" + input: "gradients_7/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_10_grad/Sum" + input: "gradients_7/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_7/filter_type_0/mul_grad/Reshape" + input: "gradients_7/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_0/add_10_grad/Sum_1" + input: "gradients_7/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/add_10_grad/Shape" + input: "gradients_7/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_1/mul_grad/Reshape" + input: "gradients_7/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_10_grad/Sum" + input: "gradients_7/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_7/filter_type_1/mul_grad/Reshape" + input: "gradients_7/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_1/add_10_grad/Sum_1" + input: "gradients_7/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients_7/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients_7/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_7/filter_type_0/MatMul_3_grad/Shape" + input: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_7/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients_7/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients_7/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/MatMul_3_grad/Sum" + input: "gradients_7/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_7/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients_7/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients_7/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients_7/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients_7/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_7/filter_type_0/MatMul_7_grad/Shape" + input: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_7/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients_7/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients_7/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/MatMul_7_grad/Sum" + input: "gradients_7/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_7/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients_7/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients_7/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients_7/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients_7/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_7/filter_type_1/MatMul_3_grad/Shape" + input: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_7/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients_7/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients_7/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/MatMul_3_grad/Sum" + input: "gradients_7/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_7/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients_7/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients_7/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients_7/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients_7/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_7/filter_type_1/MatMul_7_grad/Shape" + input: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_7/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_7/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients_7/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients_7/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/MatMul_7_grad/Sum" + input: "gradients_7/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_7/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients_7/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients_7/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients_7/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients_7/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients_7/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients_7/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients_7/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients_7/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients_7/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients_7/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/add_4_grad/Shape" + input: "gradients_7/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_7/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_4_grad/Sum" + input: "gradients_7/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_7/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_7/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_0/add_4_grad/Sum_1" + input: "gradients_7/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/add_9_grad/Shape" + input: "gradients_7/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_7/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_9_grad/Sum" + input: "gradients_7/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_7/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_7/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_0/add_9_grad/Sum_1" + input: "gradients_7/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/add_4_grad/Shape" + input: "gradients_7/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_7/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_4_grad/Sum" + input: "gradients_7/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_7/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_7/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_1/add_4_grad/Sum_1" + input: "gradients_7/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/add_9_grad/Shape" + input: "gradients_7/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_7/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_9_grad/Sum" + input: "gradients_7/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_7/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_7/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_1/add_9_grad/Sum_1" + input: "gradients_7/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_0/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_1/axis" + input: "gradients_7/filter_type_0/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_2" + input: "filter_type_0/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_7/filter_type_0/concat_1_grad/mod" + input: "gradients_7/filter_type_0/concat_1_grad/ShapeN" + input: "gradients_7/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_1_grad/Slice" + op: "Slice" + input: "gradients_7/filter_type_0/add_4_grad/Reshape" + input: "gradients_7/filter_type_0/concat_1_grad/ConcatOffset" + input: "gradients_7/filter_type_0/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_7/filter_type_0/add_4_grad/Reshape" + input: "gradients_7/filter_type_0/concat_1_grad/ConcatOffset:1" + input: "gradients_7/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_4_grad/Reshape_1" + input: "gradients_7/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_0/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_3/axis" + input: "gradients_7/filter_type_0/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_7" + input: "filter_type_0/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_7/filter_type_0/concat_3_grad/mod" + input: "gradients_7/filter_type_0/concat_3_grad/ShapeN" + input: "gradients_7/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_3_grad/Slice" + op: "Slice" + input: "gradients_7/filter_type_0/add_9_grad/Reshape" + input: "gradients_7/filter_type_0/concat_3_grad/ConcatOffset" + input: "gradients_7/filter_type_0/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_7/filter_type_0/add_9_grad/Reshape" + input: "gradients_7/filter_type_0/concat_3_grad/ConcatOffset:1" + input: "gradients_7/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_9_grad/Reshape_1" + input: "gradients_7/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_1/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_1/axis" + input: "gradients_7/filter_type_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_2" + input: "filter_type_1/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_7/filter_type_1/concat_1_grad/mod" + input: "gradients_7/filter_type_1/concat_1_grad/ShapeN" + input: "gradients_7/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients_7/filter_type_1/add_4_grad/Reshape" + input: "gradients_7/filter_type_1/concat_1_grad/ConcatOffset" + input: "gradients_7/filter_type_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_7/filter_type_1/add_4_grad/Reshape" + input: "gradients_7/filter_type_1/concat_1_grad/ConcatOffset:1" + input: "gradients_7/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_4_grad/Reshape_1" + input: "gradients_7/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_1/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_3/axis" + input: "gradients_7/filter_type_1/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_7" + input: "filter_type_1/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_7/filter_type_1/concat_3_grad/mod" + input: "gradients_7/filter_type_1/concat_3_grad/ShapeN" + input: "gradients_7/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_3_grad/Slice" + op: "Slice" + input: "gradients_7/filter_type_1/add_9_grad/Reshape" + input: "gradients_7/filter_type_1/concat_3_grad/ConcatOffset" + input: "gradients_7/filter_type_1/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_7/filter_type_1/add_9_grad/Reshape" + input: "gradients_7/filter_type_1/concat_3_grad/ConcatOffset:1" + input: "gradients_7/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_9_grad/Reshape_1" + input: "gradients_7/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients_7/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients_7/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients_7/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients_7/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/add_3_grad/Shape" + input: "gradients_7/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients_7/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_3_grad/Sum" + input: "gradients_7/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/add_8_grad/Shape" + input: "gradients_7/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients_7/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_8_grad/Sum" + input: "gradients_7/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/add_3_grad/Shape" + input: "gradients_7/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients_7/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_3_grad/Sum" + input: "gradients_7/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/add_8_grad/Shape" + input: "gradients_7/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients_7/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_8_grad/Sum" + input: "gradients_7/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_7/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_7/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_7/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_7/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/AddN_6" + op: "AddN" + input: "gradients_7/filter_type_0/concat_1_grad/Slice" + input: "gradients_7/filter_type_0/concat_1_grad/Slice_1" + input: "gradients_7/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_0/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_7/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/add_2_grad/Shape" + input: "gradients_7/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients_7/AddN_6" + input: "gradients_7/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_2_grad/Sum" + input: "gradients_7/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_7/AddN_6" + input: "gradients_7/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_0/add_2_grad/Sum_1" + input: "gradients_7/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_7" + op: "AddN" + input: "gradients_7/filter_type_0/concat_3_grad/Slice" + input: "gradients_7/filter_type_0/concat_3_grad/Slice_1" + input: "gradients_7/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_0/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_7/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/add_7_grad/Shape" + input: "gradients_7/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients_7/AddN_7" + input: "gradients_7/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_7_grad/Sum" + input: "gradients_7/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_7/AddN_7" + input: "gradients_7/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_0/add_7_grad/Sum_1" + input: "gradients_7/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_8" + op: "AddN" + input: "gradients_7/filter_type_1/concat_1_grad/Slice" + input: "gradients_7/filter_type_1/concat_1_grad/Slice_1" + input: "gradients_7/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_1/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_7/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/add_2_grad/Shape" + input: "gradients_7/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients_7/AddN_8" + input: "gradients_7/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_2_grad/Sum" + input: "gradients_7/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_7/AddN_8" + input: "gradients_7/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_1/add_2_grad/Sum_1" + input: "gradients_7/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_9" + op: "AddN" + input: "gradients_7/filter_type_1/concat_3_grad/Slice" + input: "gradients_7/filter_type_1/concat_3_grad/Slice_1" + input: "gradients_7/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_1/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_7/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/add_7_grad/Shape" + input: "gradients_7/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients_7/AddN_9" + input: "gradients_7/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_7_grad/Sum" + input: "gradients_7/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_7/AddN_9" + input: "gradients_7/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_1/add_7_grad/Sum_1" + input: "gradients_7/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_0/concat_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat/axis" + input: "gradients_7/filter_type_0/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_7/filter_type_0/concat_grad/mod" + input: "gradients_7/filter_type_0/concat_grad/ShapeN" + input: "gradients_7/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_grad/Slice" + op: "Slice" + input: "gradients_7/filter_type_0/add_2_grad/Reshape" + input: "gradients_7/filter_type_0/concat_grad/ConcatOffset" + input: "gradients_7/filter_type_0/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/concat_grad/Slice_1" + op: "Slice" + input: "gradients_7/filter_type_0/add_2_grad/Reshape" + input: "gradients_7/filter_type_0/concat_grad/ConcatOffset:1" + input: "gradients_7/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_2_grad/Reshape_1" + input: "gradients_7/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_0/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_2/axis" + input: "gradients_7/filter_type_0/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_7/filter_type_0/concat_2_grad/mod" + input: "gradients_7/filter_type_0/concat_2_grad/ShapeN" + input: "gradients_7/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_7/filter_type_0/concat_2_grad/Slice" + op: "Slice" + input: "gradients_7/filter_type_0/add_7_grad/Reshape" + input: "gradients_7/filter_type_0/concat_2_grad/ConcatOffset" + input: "gradients_7/filter_type_0/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_7/filter_type_0/add_7_grad/Reshape" + input: "gradients_7/filter_type_0/concat_2_grad/ConcatOffset:1" + input: "gradients_7/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_7_grad/Reshape_1" + input: "gradients_7/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_1/concat_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat/axis" + input: "gradients_7/filter_type_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_7/filter_type_1/concat_grad/mod" + input: "gradients_7/filter_type_1/concat_grad/ShapeN" + input: "gradients_7/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_grad/Slice" + op: "Slice" + input: "gradients_7/filter_type_1/add_2_grad/Reshape" + input: "gradients_7/filter_type_1/concat_grad/ConcatOffset" + input: "gradients_7/filter_type_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients_7/filter_type_1/add_2_grad/Reshape" + input: "gradients_7/filter_type_1/concat_grad/ConcatOffset:1" + input: "gradients_7/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_2_grad/Reshape_1" + input: "gradients_7/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_1/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_2/axis" + input: "gradients_7/filter_type_1/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_7/filter_type_1/concat_2_grad/mod" + input: "gradients_7/filter_type_1/concat_2_grad/ShapeN" + input: "gradients_7/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_7/filter_type_1/concat_2_grad/Slice" + op: "Slice" + input: "gradients_7/filter_type_1/add_7_grad/Reshape" + input: "gradients_7/filter_type_1/concat_2_grad/ConcatOffset" + input: "gradients_7/filter_type_1/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_7/filter_type_1/add_7_grad/Reshape" + input: "gradients_7/filter_type_1/concat_2_grad/ConcatOffset:1" + input: "gradients_7/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_7_grad/Reshape_1" + input: "gradients_7/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients_7/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients_7/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients_7/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients_7/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/add_1_grad/Shape" + input: "gradients_7/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients_7/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_1_grad/Sum" + input: "gradients_7/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/add_6_grad/Shape" + input: "gradients_7/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients_7/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_6_grad/Sum" + input: "gradients_7/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/add_1_grad/Shape" + input: "gradients_7/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients_7/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_1_grad/Sum" + input: "gradients_7/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/add_6_grad/Shape" + input: "gradients_7/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients_7/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_6_grad/Sum" + input: "gradients_7/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_7/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_7/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_7/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_7/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/AddN_10" + op: "AddN" + input: "gradients_7/filter_type_0/concat_grad/Slice" + input: "gradients_7/filter_type_0/concat_grad/Slice_1" + input: "gradients_7/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_0/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_7/AddN_10" + input: "gradients_7/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_11" + op: "AddN" + input: "gradients_7/filter_type_0/concat_2_grad/Slice" + input: "gradients_7/filter_type_0/concat_2_grad/Slice_1" + input: "gradients_7/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_0/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_7/AddN_11" + input: "gradients_7/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_12" + op: "AddN" + input: "gradients_7/filter_type_1/concat_grad/Slice" + input: "gradients_7/filter_type_1/concat_grad/Slice_1" + input: "gradients_7/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_1/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_7/AddN_12" + input: "gradients_7/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_13" + op: "AddN" + input: "gradients_7/filter_type_1/concat_2_grad/Slice" + input: "gradients_7/filter_type_1/concat_2_grad/Slice_1" + input: "gradients_7/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_1/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_7/AddN_13" + input: "gradients_7/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients_7/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients_7/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients_7/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients_7/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_7/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/add_grad/Shape" + input: "gradients_7/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients_7/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_grad/Sum" + input: "gradients_7/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_0/add_5_grad/Shape" + input: "gradients_7/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients_7/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/add_5_grad/Sum" + input: "gradients_7/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/add_grad/Shape" + input: "gradients_7/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients_7/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_grad/Sum" + input: "gradients_7/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_7/filter_type_1/add_5_grad/Shape" + input: "gradients_7/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_7/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients_7/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_7/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/add_5_grad/Sum" + input: "gradients_7/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_7/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_7/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_7/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_7/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/MatMul_grad/MatMul" + input: "gradients_7/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients_7/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/MatMul_grad/MatMul" + input: "gradients_7/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients_7/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients_7/filter_type_0/Slice_1_grad/Rank" + input: "gradients_7/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients_7/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients_7/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients_7/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_7/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_0/Slice_1_grad/sub_1" + input: "gradients_7/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_7/filter_type_0/Slice_1_grad/Reshape" + input: "gradients_7/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients_7/filter_type_0/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 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_7/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients_7/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients_7/filter_type_0/Slice_3_grad/Rank" + input: "gradients_7/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients_7/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients_7/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients_7/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_7/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_0/Slice_3_grad/sub_1" + input: "gradients_7/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_7/filter_type_0/Slice_3_grad/Reshape" + input: "gradients_7/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients_7/filter_type_0/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 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_7/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients_7/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_7/filter_type_1/Slice_1_grad/Rank" + input: "gradients_7/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients_7/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_7/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients_7/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_7/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_1/Slice_1_grad/sub_1" + input: "gradients_7/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_7/filter_type_1/Slice_1_grad/Reshape" + input: "gradients_7/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients_7/filter_type_1/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 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_7/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients_7/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_7/filter_type_1/Slice_3_grad/Rank" + input: "gradients_7/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients_7/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_7/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients_7/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_7/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_1/Slice_3_grad/sub_1" + input: "gradients_7/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_7/filter_type_1/Slice_3_grad/Reshape" + input: "gradients_7/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients_7/filter_type_1/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 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_7/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients_7/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/Slice_1_grad/Pad" + input: "gradients_7/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_0/Slice_3_grad/Pad" + input: "gradients_7/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/Slice_1_grad/Pad" + input: "gradients_7/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_7/filter_type_1/Slice_3_grad/Pad" + input: "gradients_7/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_14" + op: "AddN" + input: "gradients_7/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients_7/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients_7/filter_type_0/Slice_grad/Rank" + input: "gradients_7/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients_7/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients_7/filter_type_0/Slice_grad/Shape_1" + input: "gradients_7/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients_7/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_0/Slice_grad/sub_1" + input: "gradients_7/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_7/filter_type_0/Slice_grad/Reshape" + input: "gradients_7/filter_type_0/Slice_grad/Reshape_1" + input: "gradients_7/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients_7/AddN_14" + input: "gradients_7/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_15" + op: "AddN" + input: "gradients_7/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients_7/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients_7/filter_type_0/Slice_2_grad/Rank" + input: "gradients_7/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients_7/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients_7/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients_7/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_7/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_0/Slice_2_grad/sub_1" + input: "gradients_7/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_7/filter_type_0/Slice_2_grad/Reshape" + input: "gradients_7/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients_7/filter_type_0/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 + } + } +} +node { + name: "gradients_7/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_7/AddN_15" + input: "gradients_7/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_16" + op: "AddN" + input: "gradients_7/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients_7/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients_7/filter_type_1/Slice_grad/Rank" + input: "gradients_7/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients_7/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients_7/filter_type_1/Slice_grad/Shape_1" + input: "gradients_7/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_7/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_1/Slice_grad/sub_1" + input: "gradients_7/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_7/filter_type_1/Slice_grad/Reshape" + input: "gradients_7/filter_type_1/Slice_grad/Reshape_1" + input: "gradients_7/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_7/AddN_16" + input: "gradients_7/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_17" + op: "AddN" + input: "gradients_7/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients_7/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_7/filter_type_1/Slice_2_grad/Rank" + input: "gradients_7/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients_7/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_7/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients_7/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_7/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/filter_type_1/Slice_2_grad/sub_1" + input: "gradients_7/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_7/filter_type_1/Slice_2_grad/Reshape" + input: "gradients_7/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients_7/filter_type_1/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 + } + } +} +node { + name: "gradients_7/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_7/AddN_17" + input: "gradients_7/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_18" + op: "AddN" + input: "gradients_7/filter_type_0/Slice_grad/Pad" + input: "gradients_7/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_7/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_7/AddN_18" + input: "gradients_7/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_19" + op: "AddN" + input: "gradients_7/filter_type_1/Slice_grad/Pad" + input: "gradients_7/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_7/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_7/AddN_19" + input: "gradients_7/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/Slice_grad/stack" + op: "Pack" + input: "gradients_7/Slice_grad/Rank" + input: "gradients_7/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients_7/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_grad/sub" + op: "Sub" + input: "gradients_7/Slice_grad/Shape_1" + input: "gradients_7/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_grad/sub_1" + op: "Sub" + input: "gradients_7/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/Slice_grad/sub_1" + input: "gradients_7/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_7/Slice_grad/Reshape" + input: "gradients_7/Slice_grad/Reshape_1" + input: "gradients_7/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_grad/Pad" + op: "Pad" + input: "gradients_7/Reshape_5_grad/Reshape" + input: "gradients_7/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_7/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/Slice_1_grad/stack" + op: "Pack" + input: "gradients_7/Slice_1_grad/Rank" + input: "gradients_7/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_7/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients_7/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_1_grad/sub" + op: "Sub" + input: "gradients_7/Slice_1_grad/Shape_1" + input: "gradients_7/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_7/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_7/Slice_1_grad/sub_1" + input: "gradients_7/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_7/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_7/Slice_1_grad/Reshape" + input: "gradients_7/Slice_1_grad/Reshape_1" + input: "gradients_7/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 + } + } +} +node { + name: "gradients_7/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_7/Reshape_9_grad/Reshape" + input: "gradients_7/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/AddN_20" + op: "AddN" + input: "gradients_7/Slice_grad/Pad" + input: "gradients_7/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_7/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_7/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_7/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_7/AddN_20" + input: "gradients_7/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_55/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_55/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_55/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_55" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_55/stack" + input: "strided_slice_55/stack_1" + input: "strided_slice_55/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_44/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_44" + op: "Mul" + input: "strided_slice_55" + input: "mul_44/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_51/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_51/shape" + op: "Pack" + input: "Reshape_51/shape/0" + input: "mul_44" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_51" + op: "Reshape" + input: "gradients_7/Reshape_4_grad/Reshape" + input: "Reshape_51/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA_7" + op: "ProdForceSeA" + input: "Reshape_51" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA_7" + op: "ProdVirialSeA" + input: "Reshape_51" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_56/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_56/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_56/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_56" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_56/stack" + input: "strided_slice_56/stack_1" + input: "strided_slice_56/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_45/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_45" + op: "Mul" + input: "mul_45/x" + input: "strided_slice_56" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_52/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_52/shape" + op: "Pack" + input: "Reshape_52/shape/0" + input: "mul_45" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_52" + op: "Reshape" + input: "ProdForceSeA_7" + input: "Reshape_52/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_53/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_53" + op: "Reshape" + input: "ProdVirialSeA_7" + input: "Reshape_53/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_57/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_57/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_57/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_57" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_57/stack" + input: "strided_slice_57/stack_1" + input: "strided_slice_57/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_46/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_46" + op: "Mul" + input: "mul_46/x" + input: "strided_slice_57" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_54/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_54/shape" + op: "Pack" + input: "Reshape_54/shape/0" + input: "mul_46" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_54" + op: "Reshape" + input: "ProdVirialSeA_7:1" + input: "Reshape_54/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Shape" + op: "Shape" + input: "split:8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/grad_ys_0/Const" + op: "Const" + attr { + key: "dtype" + value { + type: DT_DOUBLE + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_DOUBLE + tensor_shape { + } + double_val: 1.0 + } + } + } +} +node { + name: "gradients_8/grad_ys_0" + op: "Fill" + input: "gradients_8/Shape" + input: "gradients_8/grad_ys_0/Const" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "index_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/zeros_like" + op: "ZerosLike" + input: "split" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/zeros_like_1" + op: "ZerosLike" + input: "split:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/zeros_like_2" + op: "ZerosLike" + input: "split:2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/zeros_like_3" + op: "ZerosLike" + input: "split:3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/zeros_like_4" + op: "ZerosLike" + input: "split:4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/zeros_like_5" + op: "ZerosLike" + input: "split:5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/zeros_like_6" + op: "ZerosLike" + input: "split:6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/zeros_like_7" + op: "ZerosLike" + input: "split:7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/split_grad/concat" + op: "ConcatV2" + input: "gradients_8/zeros_like" + input: "gradients_8/zeros_like_1" + input: "gradients_8/zeros_like_2" + input: "gradients_8/zeros_like_3" + input: "gradients_8/zeros_like_4" + input: "gradients_8/zeros_like_5" + input: "gradients_8/zeros_like_6" + input: "gradients_8/zeros_like_7" + input: "gradients_8/grad_ys_0" + input: "split/split_dim" + attr { + key: "N" + value { + i: 9 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_22_grad/Shape" + op: "Shape" + input: "o_polar" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_22_grad/Reshape" + op: "Reshape" + input: "gradients_8/split_grad/concat" + input: "gradients_8/Reshape_22_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/o_polar_grad/Shape" + op: "Shape" + input: "Reshape_21" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/o_polar_grad/Reshape" + op: "Reshape" + input: "gradients_8/Reshape_22_grad/Reshape" + input: "gradients_8/o_polar_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_21_grad/Shape" + op: "Shape" + input: "add_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_21_grad/Reshape" + op: "Reshape" + input: "gradients_8/o_polar_grad/Reshape" + input: "gradients_8/Reshape_21_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_7_grad/Shape" + op: "Shape" + input: "mul_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_7_grad/Shape_1" + op: "Shape" + input: "mul_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/add_7_grad/Shape" + input: "gradients_8/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_7_grad/Sum" + op: "Sum" + input: "gradients_8/Reshape_21_grad/Reshape" + input: "gradients_8/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_8/add_7_grad/Sum" + input: "gradients_8/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/mul_16_grad/Shape" + op: "Shape" + input: "Reshape_18" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/mul_16_grad/Shape_1" + op: "Shape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/mul_16_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/mul_16_grad/Shape" + input: "gradients_8/mul_16_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/mul_16_grad/Mul" + op: "Mul" + input: "gradients_8/add_7_grad/Reshape" + input: "mul_16/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/mul_16_grad/Sum" + op: "Sum" + input: "gradients_8/mul_16_grad/Mul" + input: "gradients_8/mul_16_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/mul_16_grad/Reshape" + op: "Reshape" + input: "gradients_8/mul_16_grad/Sum" + input: "gradients_8/mul_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_18_grad/Shape" + op: "Shape" + input: "MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_18_grad/Reshape" + op: "Reshape" + input: "gradients_8/mul_16_grad/Reshape" + input: "gradients_8/Reshape_18_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/MatMul_1_grad/MatMul" + op: "BatchMatMulV2" + input: "MatMul" + input: "gradients_8/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_8/MatMul_1_grad/MatMul_1" + op: "BatchMatMulV2" + input: "Reshape_16" + input: "gradients_8/Reshape_18_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_8/MatMul_1_grad/Shape" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/MatMul_1_grad/Shape_1" + op: "Shape" + input: "MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/MatMul_1_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/MatMul_1_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/MatMul_1_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/MatMul_1_grad/strided_slice" + op: "StridedSlice" + input: "gradients_8/MatMul_1_grad/Shape" + input: "gradients_8/MatMul_1_grad/strided_slice/stack" + input: "gradients_8/MatMul_1_grad/strided_slice/stack_1" + input: "gradients_8/MatMul_1_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/MatMul_1_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/MatMul_1_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/MatMul_1_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/MatMul_1_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_8/MatMul_1_grad/Shape_1" + input: "gradients_8/MatMul_1_grad/strided_slice_1/stack" + input: "gradients_8/MatMul_1_grad/strided_slice_1/stack_1" + input: "gradients_8/MatMul_1_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/MatMul_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/MatMul_1_grad/strided_slice" + input: "gradients_8/MatMul_1_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/MatMul_1_grad/Sum" + op: "Sum" + input: "gradients_8/MatMul_1_grad/MatMul" + input: "gradients_8/MatMul_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/MatMul_1_grad/Reshape" + op: "Reshape" + input: "gradients_8/MatMul_1_grad/Sum" + input: "gradients_8/MatMul_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/MatMul_1_grad/Sum_1" + op: "Sum" + input: "gradients_8/MatMul_1_grad/MatMul_1" + input: "gradients_8/MatMul_1_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/MatMul_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/MatMul_1_grad/Sum_1" + input: "gradients_8/MatMul_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/MatMul_grad/MatMul" + op: "BatchMatMulV2" + input: "gradients_8/MatMul_1_grad/Reshape_1" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_8/MatMul_grad/MatMul_1" + op: "BatchMatMulV2" + input: "add_6" + input: "gradients_8/MatMul_1_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_8/MatMul_grad/Shape" + op: "Shape" + input: "add_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/MatMul_grad/Shape_1" + op: "Shape" + input: "Reshape_16" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/MatMul_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/MatMul_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/MatMul_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/MatMul_grad/strided_slice" + op: "StridedSlice" + input: "gradients_8/MatMul_grad/Shape" + input: "gradients_8/MatMul_grad/strided_slice/stack" + input: "gradients_8/MatMul_grad/strided_slice/stack_1" + input: "gradients_8/MatMul_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/MatMul_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/MatMul_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/MatMul_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/MatMul_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_8/MatMul_grad/Shape_1" + input: "gradients_8/MatMul_grad/strided_slice_1/stack" + input: "gradients_8/MatMul_grad/strided_slice_1/stack_1" + input: "gradients_8/MatMul_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/MatMul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/MatMul_grad/strided_slice" + input: "gradients_8/MatMul_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/MatMul_grad/Sum" + op: "Sum" + input: "gradients_8/MatMul_grad/MatMul" + input: "gradients_8/MatMul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/MatMul_grad/Reshape" + op: "Reshape" + input: "gradients_8/MatMul_grad/Sum" + input: "gradients_8/MatMul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/MatMul_grad/Sum_1" + op: "Sum" + input: "gradients_8/MatMul_grad/MatMul_1" + input: "gradients_8/MatMul_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/MatMul_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/MatMul_grad/Sum_1" + input: "gradients_8/MatMul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_6_grad/Shape" + op: "Shape" + input: "Reshape_17" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_6_grad/Shape_1" + op: "Shape" + input: "transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/add_6_grad/Shape" + input: "gradients_8/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_6_grad/Sum" + op: "Sum" + input: "gradients_8/MatMul_grad/Reshape" + input: "gradients_8/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_8/add_6_grad/Sum" + input: "gradients_8/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_6_grad/Sum_1" + op: "Sum" + input: "gradients_8/MatMul_grad/Reshape" + input: "gradients_8/add_6_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/add_6_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/add_6_grad/Sum_1" + input: "gradients_8/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN" + op: "AddN" + input: "gradients_8/MatMul_1_grad/Reshape" + input: "gradients_8/MatMul_grad/Reshape_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/MatMul_1_grad/Reshape" + } + } + } +} +node { + name: "gradients_8/Reshape_16_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_16_grad/Reshape" + op: "Reshape" + input: "gradients_8/AddN" + input: "gradients_8/Reshape_16_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/transpose_grad/transpose" + op: "Transpose" + input: "gradients_8/add_6_grad/Reshape_1" + input: "gradients_8/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/Slice_3_grad/Shape" + op: "Shape" + input: "Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/Slice_3_grad/stack" + op: "Pack" + input: "gradients_8/Slice_3_grad/Rank" + input: "gradients_8/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/Slice_3_grad/Reshape" + op: "Reshape" + input: "Slice_3/begin" + input: "gradients_8/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_3_grad/Shape_1" + op: "Shape" + input: "Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_3_grad/sub" + op: "Sub" + input: "gradients_8/Slice_3_grad/Shape_1" + input: "gradients_8/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_8/Slice_3_grad/sub" + input: "Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/Slice_3_grad/sub_1" + input: "gradients_8/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_8/Slice_3_grad/Reshape" + input: "gradients_8/Slice_3_grad/Reshape_1" + input: "gradients_8/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 + } + } +} +node { + name: "gradients_8/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_8/Reshape_16_grad/Reshape" + input: "gradients_8/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_1" + op: "AddN" + input: "gradients_8/add_6_grad/Reshape" + input: "gradients_8/transpose_grad/transpose" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/add_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_8/Reshape_17_grad/Shape" + op: "Shape" + input: "final_layer_type_0/add" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_17_grad/Reshape" + op: "Reshape" + input: "gradients_8/AddN_1" + input: "gradients_8/Reshape_17_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_14_grad/Shape" + op: "Shape" + input: "o_rot_mat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_8/Slice_3_grad/Pad" + input: "gradients_8/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/final_layer_type_0/add_grad/Shape" + op: "Shape" + input: "final_layer_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/final_layer_type_0/add_grad/Shape_1" + op: "Shape" + input: "final_layer_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/final_layer_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/final_layer_type_0/add_grad/Shape" + input: "gradients_8/final_layer_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/final_layer_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_8/Reshape_17_grad/Reshape" + input: "gradients_8/final_layer_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/final_layer_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_8/final_layer_type_0/add_grad/Sum" + input: "gradients_8/final_layer_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/final_layer_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_8/final_layer_type_0/add_grad/Reshape" + input: "final_layer_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/concat_1_grad/mod" + op: "FloorMod" + input: "concat_1/axis" + input: "gradients_8/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/concat_1_grad/ShapeN" + op: "ShapeN" + input: "Reshape_8" + input: "Reshape_12" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_8/concat_1_grad/mod" + input: "gradients_8/concat_1_grad/ShapeN" + input: "gradients_8/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_8/concat_1_grad/Slice" + op: "Slice" + input: "gradients_8/Reshape_14_grad/Reshape" + input: "gradients_8/concat_1_grad/ConcatOffset" + input: "gradients_8/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_8/Reshape_14_grad/Reshape" + input: "gradients_8/concat_1_grad/ConcatOffset:1" + input: "gradients_8/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/add_5_grad/Shape" + op: "Shape" + input: "add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_5_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/add_5_grad/Shape" + input: "gradients_8/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_5_grad/Sum" + op: "Sum" + input: "gradients_8/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_8/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_8/add_5_grad/Sum" + input: "gradients_8/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_5_grad/Sum_1" + op: "Sum" + input: "gradients_8/final_layer_type_0/MatMul_grad/MatMul" + input: "gradients_8/add_5_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/add_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/add_5_grad/Sum_1" + input: "gradients_8/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_8/concat_1_grad/Slice" + input: "gradients_8/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/transpose" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_8/concat_1_grad/Slice_1" + input: "gradients_8/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_2_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_2_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_2_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/layer_2_type_0/mul_grad/Shape" + input: "gradients_8/layer_2_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_2_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_8/add_5_grad/Reshape_1" + input: "layer_2_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/layer_2_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_8/layer_2_type_0/mul_grad/Mul" + input: "gradients_8/layer_2_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/layer_2_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_8/layer_2_type_0/mul_grad/Sum" + input: "gradients_8/layer_2_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_0/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/transpose_grad/transpose" + op: "Transpose" + input: "gradients_8/Reshape_8_grad/Reshape" + input: "gradients_8/filter_type_0/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/transpose_grad/InvertPermutation" + op: "InvertPermutation" + input: "filter_type_1/transpose/perm" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/transpose_grad/transpose" + op: "Transpose" + input: "gradients_8/Reshape_12_grad/Reshape" + input: "gradients_8/filter_type_1/transpose_grad/InvertPermutation" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tperm" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_2_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_2_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_2_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_8/layer_2_type_0/mul_grad/Reshape" + input: "gradients_8/layer_2_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_5_grad/stack" + op: "Pack" + input: "gradients_8/filter_type_0/Slice_5_grad/Rank" + input: "gradients_8/filter_type_0/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_5/begin" + input: "gradients_8/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_5_grad/sub" + op: "Sub" + input: "gradients_8/filter_type_0/Slice_5_grad/Shape_1" + input: "gradients_8/filter_type_0/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_8/filter_type_0/Slice_5_grad/sub" + input: "filter_type_0/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_0/Slice_5_grad/sub_1" + input: "gradients_8/filter_type_0/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_8/filter_type_0/Slice_5_grad/Reshape" + input: "gradients_8/filter_type_0/Slice_5_grad/Reshape_1" + input: "gradients_8/filter_type_0/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 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_8/filter_type_0/transpose_grad/transpose" + input: "gradients_8/filter_type_0/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_5_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_5_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_5_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_5_grad/stack" + op: "Pack" + input: "gradients_8/filter_type_1/Slice_5_grad/Rank" + input: "gradients_8/filter_type_1/Slice_5_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_5_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_5/begin" + input: "gradients_8/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_5_grad/sub" + op: "Sub" + input: "gradients_8/filter_type_1/Slice_5_grad/Shape_1" + input: "gradients_8/filter_type_1/Slice_5_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_5_grad/sub_1" + op: "Sub" + input: "gradients_8/filter_type_1/Slice_5_grad/sub" + input: "filter_type_1/Slice_5/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_5_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_1/Slice_5_grad/sub_1" + input: "gradients_8/filter_type_1/Slice_5_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_5_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_5_grad/concat" + op: "ConcatV2" + input: "gradients_8/filter_type_1/Slice_5_grad/Reshape" + input: "gradients_8/filter_type_1/Slice_5_grad/Reshape_1" + input: "gradients_8/filter_type_1/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 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_5_grad/Pad" + op: "Pad" + input: "gradients_8/filter_type_1/transpose_grad/transpose" + input: "gradients_8/filter_type_1/Slice_5_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_2_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_2_type_0/Tanh" + input: "gradients_8/layer_2_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/layer_2_type_0/add_grad/Shape" + op: "Shape" + input: "layer_2_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_2_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_2_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_2_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/layer_2_type_0/add_grad/Shape" + input: "gradients_8/layer_2_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_2_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_8/layer_2_type_0/Tanh_grad/TanhGrad" + input: "gradients_8/layer_2_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/layer_2_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_8/layer_2_type_0/add_grad/Sum" + input: "gradients_8/layer_2_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_2_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_8/layer_2_type_0/add_grad/Reshape" + input: "layer_2_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/AddN_2" + op: "AddN" + input: "gradients_8/add_5_grad/Reshape" + input: "gradients_8/layer_2_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/add_5_grad/Reshape" + } + } + } +} +node { + name: "gradients_8/add_4_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_4_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/add_4_grad/Shape" + input: "gradients_8/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_4_grad/Sum" + op: "Sum" + input: "gradients_8/AddN_2" + input: "gradients_8/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_8/add_4_grad/Sum" + input: "gradients_8/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_8/AddN_2" + input: "gradients_8/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/add_4_grad/Sum_1" + input: "gradients_8/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_1_type_0/mul_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_1_type_0/mul_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_1_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/layer_1_type_0/mul_grad/Shape" + input: "gradients_8/layer_1_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_1_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_8/add_4_grad/Reshape_1" + input: "layer_1_type_0/idt/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/layer_1_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_8/layer_1_type_0/mul_grad/Mul" + input: "gradients_8/layer_1_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/layer_1_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_8/layer_1_type_0/mul_grad/Sum" + input: "gradients_8/layer_1_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_1_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_1_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_1_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_8/layer_1_type_0/mul_grad/Reshape" + input: "gradients_8/layer_1_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_1_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_1_type_0/Tanh" + input: "gradients_8/layer_1_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/layer_1_type_0/add_grad/Shape" + op: "Shape" + input: "layer_1_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_1_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_1_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_1_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/layer_1_type_0/add_grad/Shape" + input: "gradients_8/layer_1_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_1_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_8/layer_1_type_0/Tanh_grad/TanhGrad" + input: "gradients_8/layer_1_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/layer_1_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_8/layer_1_type_0/add_grad/Sum" + input: "gradients_8/layer_1_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_1_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_8/layer_1_type_0/add_grad/Reshape" + input: "layer_1_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/AddN_3" + op: "AddN" + input: "gradients_8/add_4_grad/Reshape" + input: "gradients_8/layer_1_type_0/MatMul_grad/MatMul" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/add_4_grad/Reshape" + } + } + } +} +node { + name: "gradients_8/layer_0_type_0/Reshape_grad/Shape" + op: "Shape" + input: "layer_0_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_0_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_8/AddN_3" + input: "gradients_8/layer_0_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_0_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "layer_0_type_0/Tanh" + input: "gradients_8/layer_0_type_0/Reshape_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/layer_0_type_0/add_grad/Shape" + op: "Shape" + input: "layer_0_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_0_type_0/add_grad/Shape_1" + op: "Shape" + input: "layer_0_type_0/bias/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_0_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/layer_0_type_0/add_grad/Shape" + input: "gradients_8/layer_0_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_0_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_8/layer_0_type_0/Tanh_grad/TanhGrad" + input: "gradients_8/layer_0_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/layer_0_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_8/layer_0_type_0/add_grad/Sum" + input: "gradients_8/layer_0_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/layer_0_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_8/layer_0_type_0/add_grad/Reshape" + input: "layer_0_type_0/matrix/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/Reshape_15_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_15_grad/Reshape" + op: "Reshape" + input: "gradients_8/layer_0_type_0/MatMul_grad/MatMul" + input: "gradients_8/Reshape_15_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/Slice_2_grad/Shape" + op: "Shape" + input: "Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/Slice_2_grad/stack" + op: "Pack" + input: "gradients_8/Slice_2_grad/Rank" + input: "gradients_8/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/Slice_2_grad/Reshape" + op: "Reshape" + input: "Slice_2/begin" + input: "gradients_8/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_2_grad/sub" + op: "Sub" + input: "gradients_8/Slice_2_grad/Shape_1" + input: "gradients_8/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_8/Slice_2_grad/sub" + input: "Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/Slice_2_grad/sub_1" + input: "gradients_8/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_8/Slice_2_grad/Reshape" + input: "gradients_8/Slice_2_grad/Reshape_1" + input: "gradients_8/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 + } + } +} +node { + name: "gradients_8/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_8/Reshape_15_grad/Reshape" + input: "gradients_8/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_13_grad/Shape" + op: "Shape" + input: "o_descriptor" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_8/Slice_2_grad/Pad" + input: "gradients_8/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/concat_grad/mod" + op: "FloorMod" + input: "concat/axis" + input: "gradients_8/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/concat_grad/ShapeN" + op: "ShapeN" + input: "Reshape_7" + input: "Reshape_11" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_8/concat_grad/mod" + input: "gradients_8/concat_grad/ShapeN" + input: "gradients_8/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_8/concat_grad/Slice" + op: "Slice" + input: "gradients_8/Reshape_13_grad/Reshape" + input: "gradients_8/concat_grad/ConcatOffset" + input: "gradients_8/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/concat_grad/Slice_1" + op: "Slice" + input: "gradients_8/Reshape_13_grad/Reshape" + input: "gradients_8/concat_grad/ConcatOffset:1" + input: "gradients_8/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_8/concat_grad/Slice" + input: "gradients_8/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_14" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_8/concat_grad/Slice_1" + input: "gradients_8/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_8/Reshape_7_grad/Reshape" + input: "gradients_8/filter_type_0/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_14_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_8" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_14_grad/Reshape" + op: "Reshape" + input: "gradients_8/Reshape_11_grad/Reshape" + input: "gradients_8/filter_type_1/Reshape_14_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Slice_4" + input: "gradients_8/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/mul" + input: "gradients_8/filter_type_0/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_8/filter_type_0/MatMul_8_grad/Shape" + input: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice/stack" + input: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_8/filter_type_0/MatMul_8_grad/Shape_1" + input: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice" + input: "gradients_8/filter_type_0/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_0/MatMul_8_grad/MatMul" + input: "gradients_8/filter_type_0/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/MatMul_8_grad/Sum" + input: "gradients_8/filter_type_0/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_8/filter_type_0/MatMul_8_grad/MatMul_1" + input: "gradients_8/filter_type_0/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_0/MatMul_8_grad/Sum_1" + input: "gradients_8/filter_type_0/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Slice_4" + input: "gradients_8/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/mul" + input: "gradients_8/filter_type_1/Reshape_14_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/Shape" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice" + op: "StridedSlice" + input: "gradients_8/filter_type_1/MatMul_8_grad/Shape" + input: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice/stack" + input: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice/stack_1" + input: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_8/filter_type_1/MatMul_8_grad/Shape_1" + input: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice_1/stack" + input: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice_1/stack_1" + input: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice" + input: "gradients_8/filter_type_1/MatMul_8_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_1/MatMul_8_grad/MatMul" + input: "gradients_8/filter_type_1/MatMul_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/MatMul_8_grad/Sum" + input: "gradients_8/filter_type_1/MatMul_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/Sum_1" + op: "Sum" + input: "gradients_8/filter_type_1/MatMul_8_grad/MatMul_1" + input: "gradients_8/filter_type_1/MatMul_8_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_8_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_1/MatMul_8_grad/Sum_1" + input: "gradients_8/filter_type_1/MatMul_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_4_grad/stack" + op: "Pack" + input: "gradients_8/filter_type_0/Slice_4_grad/Rank" + input: "gradients_8/filter_type_0/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_4/begin" + input: "gradients_8/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_4_grad/sub" + op: "Sub" + input: "gradients_8/filter_type_0/Slice_4_grad/Shape_1" + input: "gradients_8/filter_type_0/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_8/filter_type_0/Slice_4_grad/sub" + input: "filter_type_0/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_0/Slice_4_grad/sub_1" + input: "gradients_8/filter_type_0/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_8/filter_type_0/Slice_4_grad/Reshape" + input: "gradients_8/filter_type_0/Slice_4_grad/Reshape_1" + input: "gradients_8/filter_type_0/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 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_8/filter_type_0/MatMul_8_grad/Reshape_1" + input: "gradients_8/filter_type_0/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_4_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_4_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_4_grad/stack" + op: "Pack" + input: "gradients_8/filter_type_1/Slice_4_grad/Rank" + input: "gradients_8/filter_type_1/Slice_4_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_4_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_4/begin" + input: "gradients_8/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_4_grad/sub" + op: "Sub" + input: "gradients_8/filter_type_1/Slice_4_grad/Shape_1" + input: "gradients_8/filter_type_1/Slice_4_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_4_grad/sub_1" + op: "Sub" + input: "gradients_8/filter_type_1/Slice_4_grad/sub" + input: "filter_type_1/Slice_4/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_1/Slice_4_grad/sub_1" + input: "gradients_8/filter_type_1/Slice_4_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_4_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_4_grad/concat" + op: "ConcatV2" + input: "gradients_8/filter_type_1/Slice_4_grad/Reshape" + input: "gradients_8/filter_type_1/Slice_4_grad/Reshape_1" + input: "gradients_8/filter_type_1/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 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_4_grad/Pad" + op: "Pad" + input: "gradients_8/filter_type_1/MatMul_8_grad/Reshape_1" + input: "gradients_8/filter_type_1/Slice_4_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_4" + op: "AddN" + input: "gradients_8/filter_type_0/Slice_5_grad/Pad" + input: "gradients_8/filter_type_0/MatMul_8_grad/Reshape" + input: "gradients_8/filter_type_0/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_0/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_8/filter_type_0/mul_grad/Shape" + op: "Shape" + input: "filter_type_0/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/mul_grad/Shape" + input: "gradients_8/filter_type_0/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/mul_grad/Mul" + op: "Mul" + input: "gradients_8/AddN_4" + input: "filter_type_0/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/mul_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_0/mul_grad/Mul" + input: "gradients_8/filter_type_0/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/mul_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/mul_grad/Sum" + input: "gradients_8/filter_type_0/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_5" + op: "AddN" + input: "gradients_8/filter_type_1/Slice_5_grad/Pad" + input: "gradients_8/filter_type_1/MatMul_8_grad/Reshape" + input: "gradients_8/filter_type_1/Slice_4_grad/Pad" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_1/Slice_5_grad/Pad" + } + } + } +} +node { + name: "gradients_8/filter_type_1/mul_grad/Shape" + op: "Shape" + input: "filter_type_1/add_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/mul_grad/Shape_1" + op: "Shape" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/mul_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/mul_grad/Shape" + input: "gradients_8/filter_type_1/mul_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/mul_grad/Mul" + op: "Mul" + input: "gradients_8/AddN_5" + input: "filter_type_1/mul/y" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/mul_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_1/mul_grad/Mul" + input: "gradients_8/filter_type_1/mul_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/mul_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/mul_grad/Sum" + input: "gradients_8/filter_type_1/mul_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_10_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_0/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/add_10_grad/Shape" + input: "gradients_8/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_10_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_0/mul_grad/Reshape" + input: "gradients_8/filter_type_0/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_10_grad/Sum" + input: "gradients_8/filter_type_0/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_8/filter_type_0/mul_grad/Reshape" + input: "gradients_8/filter_type_0/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_0/add_10_grad/Sum_1" + input: "gradients_8/filter_type_0/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_10_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_10_grad/Shape_1" + op: "Shape" + input: "filter_type_1/MatMul_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_10_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/add_10_grad/Shape" + input: "gradients_8/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_10_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_1/mul_grad/Reshape" + input: "gradients_8/filter_type_1/add_10_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_10_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_10_grad/Sum" + input: "gradients_8/filter_type_1/add_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_10_grad/Sum_1" + op: "Sum" + input: "gradients_8/filter_type_1/mul_grad/Reshape" + input: "gradients_8/filter_type_1/add_10_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_10_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_1/add_10_grad/Sum_1" + input: "gradients_8/filter_type_1/add_10_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_5" + input: "gradients_8/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_6" + input: "gradients_8/filter_type_0/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_8/filter_type_0/MatMul_3_grad/Shape" + input: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice/stack" + input: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_8/filter_type_0/MatMul_3_grad/Shape_1" + input: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice" + input: "gradients_8/filter_type_0/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_0/MatMul_3_grad/MatMul" + input: "gradients_8/filter_type_0/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/MatMul_3_grad/Sum" + input: "gradients_8/filter_type_0/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_8/filter_type_0/MatMul_3_grad/MatMul_1" + input: "gradients_8/filter_type_0/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_0/MatMul_3_grad/Sum_1" + input: "gradients_8/filter_type_0/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_12" + input: "gradients_8/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_0/Reshape_13" + input: "gradients_8/filter_type_0/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_8/filter_type_0/MatMul_7_grad/Shape" + input: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice/stack" + input: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_8/filter_type_0/MatMul_7_grad/Shape_1" + input: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice" + input: "gradients_8/filter_type_0/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_0/MatMul_7_grad/MatMul" + input: "gradients_8/filter_type_0/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/MatMul_7_grad/Sum" + input: "gradients_8/filter_type_0/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_8/filter_type_0/MatMul_7_grad/MatMul_1" + input: "gradients_8/filter_type_0/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_0/MatMul_7_grad/Sum_1" + input: "gradients_8/filter_type_0/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_5" + input: "gradients_8/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_6" + input: "gradients_8/filter_type_1/add_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice" + op: "StridedSlice" + input: "gradients_8/filter_type_1/MatMul_3_grad/Shape" + input: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice/stack" + input: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice/stack_1" + input: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_8/filter_type_1/MatMul_3_grad/Shape_1" + input: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice_1/stack" + input: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice_1/stack_1" + input: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice" + input: "gradients_8/filter_type_1/MatMul_3_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_1/MatMul_3_grad/MatMul" + input: "gradients_8/filter_type_1/MatMul_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/MatMul_3_grad/Sum" + input: "gradients_8/filter_type_1/MatMul_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/Sum_1" + op: "Sum" + input: "gradients_8/filter_type_1/MatMul_3_grad/MatMul_1" + input: "gradients_8/filter_type_1/MatMul_3_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_1/MatMul_3_grad/Sum_1" + input: "gradients_8/filter_type_1/MatMul_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/MatMul" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_12" + input: "gradients_8/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/MatMul_1" + op: "BatchMatMulV2" + input: "filter_type_1/Reshape_13" + input: "gradients_8/filter_type_1/add_10_grad/Reshape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "adj_x" + value { + b: false + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Reshape_13" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_12" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice" + op: "StridedSlice" + input: "gradients_8/filter_type_1/MatMul_7_grad/Shape" + input: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice/stack" + input: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice/stack_1" + input: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -2 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice_1" + op: "StridedSlice" + input: "gradients_8/filter_type_1/MatMul_7_grad/Shape_1" + input: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice_1/stack" + input: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice_1/stack_1" + input: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + 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: "gradients_8/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice" + input: "gradients_8/filter_type_1/MatMul_7_grad/strided_slice_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_1/MatMul_7_grad/MatMul" + input: "gradients_8/filter_type_1/MatMul_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/MatMul_7_grad/Sum" + input: "gradients_8/filter_type_1/MatMul_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/Sum_1" + op: "Sum" + input: "gradients_8/filter_type_1/MatMul_7_grad/MatMul_1" + input: "gradients_8/filter_type_1/MatMul_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_1/MatMul_7_grad/Sum_1" + input: "gradients_8/filter_type_1/MatMul_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/MatMul_3_grad/Reshape" + input: "gradients_8/filter_type_0/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_0/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/MatMul_3_grad/Reshape_1" + input: "gradients_8/filter_type_0/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/MatMul_7_grad/Reshape" + input: "gradients_8/filter_type_0/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_0/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/MatMul_7_grad/Reshape_1" + input: "gradients_8/filter_type_0/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_6_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_6_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/MatMul_3_grad/Reshape" + input: "gradients_8/filter_type_1/Reshape_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_5_grad/Shape" + op: "Shape" + input: "filter_type_1/add_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/MatMul_3_grad/Reshape_1" + input: "gradients_8/filter_type_1/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_13_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_13_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/MatMul_7_grad/Reshape" + input: "gradients_8/filter_type_1/Reshape_13_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_12_grad/Shape" + op: "Shape" + input: "filter_type_1/add_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_12_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/MatMul_7_grad/Reshape_1" + input: "gradients_8/filter_type_1/Reshape_12_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_4_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/add_4_grad/Shape" + input: "gradients_8/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_4_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_8/filter_type_0/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_4_grad/Sum" + input: "gradients_8/filter_type_0/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_8/filter_type_0/Reshape_5_grad/Reshape" + input: "gradients_8/filter_type_0/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_0/add_4_grad/Sum_1" + input: "gradients_8/filter_type_0/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_9_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/add_9_grad/Shape" + input: "gradients_8/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_9_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_8/filter_type_0/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_9_grad/Sum" + input: "gradients_8/filter_type_0/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_8/filter_type_0/Reshape_12_grad/Reshape" + input: "gradients_8/filter_type_0/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_0/add_9_grad/Sum_1" + input: "gradients_8/filter_type_0/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_4_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_4_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_4_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/add_4_grad/Shape" + input: "gradients_8/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_4_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_8/filter_type_1/add_4_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_4_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_4_grad/Sum" + input: "gradients_8/filter_type_1/add_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_4_grad/Sum_1" + op: "Sum" + input: "gradients_8/filter_type_1/Reshape_5_grad/Reshape" + input: "gradients_8/filter_type_1/add_4_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_4_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_1/add_4_grad/Sum_1" + input: "gradients_8/filter_type_1/add_4_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_9_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_9_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_11" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_9_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/add_9_grad/Shape" + input: "gradients_8/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_9_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_8/filter_type_1/add_9_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_9_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_9_grad/Sum" + input: "gradients_8/filter_type_1/add_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_9_grad/Sum_1" + op: "Sum" + input: "gradients_8/filter_type_1/Reshape_12_grad/Reshape" + input: "gradients_8/filter_type_1/add_9_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_9_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_1/add_9_grad/Sum_1" + input: "gradients_8/filter_type_1/add_9_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_0/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_1/axis" + input: "gradients_8/filter_type_0/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_2" + input: "filter_type_0/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_8/filter_type_0/concat_1_grad/mod" + input: "gradients_8/filter_type_0/concat_1_grad/ShapeN" + input: "gradients_8/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_1_grad/Slice" + op: "Slice" + input: "gradients_8/filter_type_0/add_4_grad/Reshape" + input: "gradients_8/filter_type_0/concat_1_grad/ConcatOffset" + input: "gradients_8/filter_type_0/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_8/filter_type_0/add_4_grad/Reshape" + input: "gradients_8/filter_type_0/concat_1_grad/ConcatOffset:1" + input: "gradients_8/filter_type_0/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_4_grad/Reshape_1" + input: "gradients_8/filter_type_0/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_0/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_3/axis" + input: "gradients_8/filter_type_0/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/add_7" + input: "filter_type_0/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_8/filter_type_0/concat_3_grad/mod" + input: "gradients_8/filter_type_0/concat_3_grad/ShapeN" + input: "gradients_8/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_3_grad/Slice" + op: "Slice" + input: "gradients_8/filter_type_0/add_9_grad/Reshape" + input: "gradients_8/filter_type_0/concat_3_grad/ConcatOffset" + input: "gradients_8/filter_type_0/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_8/filter_type_0/add_9_grad/Reshape" + input: "gradients_8/filter_type_0/concat_3_grad/ConcatOffset:1" + input: "gradients_8/filter_type_0/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_9_grad/Reshape_1" + input: "gradients_8/filter_type_0/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_1/concat_1_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_1/axis" + input: "gradients_8/filter_type_1/concat_1_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_1_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_2" + input: "filter_type_1/add_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_1_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_8/filter_type_1/concat_1_grad/mod" + input: "gradients_8/filter_type_1/concat_1_grad/ShapeN" + input: "gradients_8/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_1_grad/Slice" + op: "Slice" + input: "gradients_8/filter_type_1/add_4_grad/Reshape" + input: "gradients_8/filter_type_1/concat_1_grad/ConcatOffset" + input: "gradients_8/filter_type_1/concat_1_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/concat_1_grad/Slice_1" + op: "Slice" + input: "gradients_8/filter_type_1/add_4_grad/Reshape" + input: "gradients_8/filter_type_1/concat_1_grad/ConcatOffset:1" + input: "gradients_8/filter_type_1/concat_1_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_4_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_4_grad/Reshape_1" + input: "gradients_8/filter_type_1/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_1/concat_3_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_3/axis" + input: "gradients_8/filter_type_1/concat_3_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_3_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/add_7" + input: "filter_type_1/add_7" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_3_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_8/filter_type_1/concat_3_grad/mod" + input: "gradients_8/filter_type_1/concat_3_grad/ShapeN" + input: "gradients_8/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_3_grad/Slice" + op: "Slice" + input: "gradients_8/filter_type_1/add_9_grad/Reshape" + input: "gradients_8/filter_type_1/concat_3_grad/ConcatOffset" + input: "gradients_8/filter_type_1/concat_3_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/concat_3_grad/Slice_1" + op: "Slice" + input: "gradients_8/filter_type_1/add_9_grad/Reshape" + input: "gradients_8/filter_type_1/concat_3_grad/ConcatOffset:1" + input: "gradients_8/filter_type_1/concat_3_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_11_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_11_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_9_grad/Reshape_1" + input: "gradients_8/filter_type_1/Reshape_11_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_2" + input: "gradients_8/filter_type_0/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_5" + input: "gradients_8/filter_type_0/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/Tanh_2_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_2" + input: "gradients_8/filter_type_1/Reshape_4_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/Tanh_5_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_5" + input: "gradients_8/filter_type_1/Reshape_11_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/add_3_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/add_3_grad/Shape" + input: "gradients_8/filter_type_0/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_3_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_0/Tanh_2_grad/TanhGrad" + input: "gradients_8/filter_type_0/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_3_grad/Sum" + input: "gradients_8/filter_type_0/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_8_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/add_8_grad/Shape" + input: "gradients_8/filter_type_0/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_8_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_0/Tanh_5_grad/TanhGrad" + input: "gradients_8/filter_type_0/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_8_grad/Sum" + input: "gradients_8/filter_type_0/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_3_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_3_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/add_3_grad/Shape" + input: "gradients_8/filter_type_1/add_3_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_3_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_1/Tanh_2_grad/TanhGrad" + input: "gradients_8/filter_type_1/add_3_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_3_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_3_grad/Sum" + input: "gradients_8/filter_type_1/add_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_8_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_6" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_8_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_8_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/add_8_grad/Shape" + input: "gradients_8/filter_type_1/add_8_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_8_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_1/Tanh_5_grad/TanhGrad" + input: "gradients_8/filter_type_1/add_8_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_8_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_8_grad/Sum" + input: "gradients_8/filter_type_1/add_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_8/filter_type_0/add_3_grad/Reshape" + input: "filter_type_0/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_8/filter_type_0/add_8_grad/Reshape" + input: "filter_type_0/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_2_grad/MatMul" + op: "MatMul" + input: "gradients_8/filter_type_1/add_3_grad/Reshape" + input: "filter_type_1/matrix_3_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_6_grad/MatMul" + op: "MatMul" + input: "gradients_8/filter_type_1/add_8_grad/Reshape" + input: "filter_type_1/matrix_3_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/AddN_6" + op: "AddN" + input: "gradients_8/filter_type_0/concat_1_grad/Slice" + input: "gradients_8/filter_type_0/concat_1_grad/Slice_1" + input: "gradients_8/filter_type_0/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_0/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_8/filter_type_0/add_2_grad/Shape" + op: "Shape" + input: "filter_type_0/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/add_2_grad/Shape" + input: "gradients_8/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_2_grad/Sum" + op: "Sum" + input: "gradients_8/AddN_6" + input: "gradients_8/filter_type_0/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_2_grad/Sum" + input: "gradients_8/filter_type_0/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_8/AddN_6" + input: "gradients_8/filter_type_0/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_0/add_2_grad/Sum_1" + input: "gradients_8/filter_type_0/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_7" + op: "AddN" + input: "gradients_8/filter_type_0/concat_3_grad/Slice" + input: "gradients_8/filter_type_0/concat_3_grad/Slice_1" + input: "gradients_8/filter_type_0/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_0/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_8/filter_type_0/add_7_grad/Shape" + op: "Shape" + input: "filter_type_0/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/add_7_grad/Shape" + input: "gradients_8/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_7_grad/Sum" + op: "Sum" + input: "gradients_8/AddN_7" + input: "gradients_8/filter_type_0/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_7_grad/Sum" + input: "gradients_8/filter_type_0/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_8/AddN_7" + input: "gradients_8/filter_type_0/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_0/add_7_grad/Sum_1" + input: "gradients_8/filter_type_0/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_8" + op: "AddN" + input: "gradients_8/filter_type_1/concat_1_grad/Slice" + input: "gradients_8/filter_type_1/concat_1_grad/Slice_1" + input: "gradients_8/filter_type_1/MatMul_2_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_1/concat_1_grad/Slice" + } + } + } +} +node { + name: "gradients_8/filter_type_1/add_2_grad/Shape" + op: "Shape" + input: "filter_type_1/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_2_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_2_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/add_2_grad/Shape" + input: "gradients_8/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_2_grad/Sum" + op: "Sum" + input: "gradients_8/AddN_8" + input: "gradients_8/filter_type_1/add_2_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_2_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_2_grad/Sum" + input: "gradients_8/filter_type_1/add_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_2_grad/Sum_1" + op: "Sum" + input: "gradients_8/AddN_8" + input: "gradients_8/filter_type_1/add_2_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_1/add_2_grad/Sum_1" + input: "gradients_8/filter_type_1/add_2_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_9" + op: "AddN" + input: "gradients_8/filter_type_1/concat_3_grad/Slice" + input: "gradients_8/filter_type_1/concat_3_grad/Slice_1" + input: "gradients_8/filter_type_1/MatMul_6_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_1/concat_3_grad/Slice" + } + } + } +} +node { + name: "gradients_8/filter_type_1/add_7_grad/Shape" + op: "Shape" + input: "filter_type_1/concat_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_7_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_10" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_7_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/add_7_grad/Shape" + input: "gradients_8/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_7_grad/Sum" + op: "Sum" + input: "gradients_8/AddN_9" + input: "gradients_8/filter_type_1/add_7_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_7_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_7_grad/Sum" + input: "gradients_8/filter_type_1/add_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_7_grad/Sum_1" + op: "Sum" + input: "gradients_8/AddN_9" + input: "gradients_8/filter_type_1/add_7_grad/BroadcastGradientArgs:1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_7_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_1/add_7_grad/Sum_1" + input: "gradients_8/filter_type_1/add_7_grad/Shape_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_0/concat_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat/axis" + input: "gradients_8/filter_type_0/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_2" + input: "filter_type_0/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_8/filter_type_0/concat_grad/mod" + input: "gradients_8/filter_type_0/concat_grad/ShapeN" + input: "gradients_8/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_grad/Slice" + op: "Slice" + input: "gradients_8/filter_type_0/add_2_grad/Reshape" + input: "gradients_8/filter_type_0/concat_grad/ConcatOffset" + input: "gradients_8/filter_type_0/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/concat_grad/Slice_1" + op: "Slice" + input: "gradients_8/filter_type_0/add_2_grad/Reshape" + input: "gradients_8/filter_type_0/concat_grad/ConcatOffset:1" + input: "gradients_8/filter_type_0/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_2_grad/Reshape_1" + input: "gradients_8/filter_type_0/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_0/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_0/concat_2/axis" + input: "gradients_8/filter_type_0/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_0/Reshape_9" + input: "filter_type_0/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_8/filter_type_0/concat_2_grad/mod" + input: "gradients_8/filter_type_0/concat_2_grad/ShapeN" + input: "gradients_8/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_8/filter_type_0/concat_2_grad/Slice" + op: "Slice" + input: "gradients_8/filter_type_0/add_7_grad/Reshape" + input: "gradients_8/filter_type_0/concat_2_grad/ConcatOffset" + input: "gradients_8/filter_type_0/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_8/filter_type_0/add_7_grad/Reshape" + input: "gradients_8/filter_type_0/concat_2_grad/ConcatOffset:1" + input: "gradients_8/filter_type_0/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_7_grad/Reshape_1" + input: "gradients_8/filter_type_0/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_1/concat_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat/axis" + input: "gradients_8/filter_type_1/concat_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_2" + input: "filter_type_1/Reshape_2" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_8/filter_type_1/concat_grad/mod" + input: "gradients_8/filter_type_1/concat_grad/ShapeN" + input: "gradients_8/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_grad/Slice" + op: "Slice" + input: "gradients_8/filter_type_1/add_2_grad/Reshape" + input: "gradients_8/filter_type_1/concat_grad/ConcatOffset" + input: "gradients_8/filter_type_1/concat_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/concat_grad/Slice_1" + op: "Slice" + input: "gradients_8/filter_type_1/add_2_grad/Reshape" + input: "gradients_8/filter_type_1/concat_grad/ConcatOffset:1" + input: "gradients_8/filter_type_1/concat_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_3_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_2_grad/Reshape_1" + input: "gradients_8/filter_type_1/Reshape_3_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_1/concat_2_grad/mod" + op: "FloorMod" + input: "filter_type_1/concat_2/axis" + input: "gradients_8/filter_type_1/concat_2_grad/Rank" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_2_grad/ShapeN" + op: "ShapeN" + input: "filter_type_1/Reshape_9" + input: "filter_type_1/Reshape_9" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_2_grad/ConcatOffset" + op: "ConcatOffset" + input: "gradients_8/filter_type_1/concat_2_grad/mod" + input: "gradients_8/filter_type_1/concat_2_grad/ShapeN" + input: "gradients_8/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "N" + value { + i: 2 + } + } +} +node { + name: "gradients_8/filter_type_1/concat_2_grad/Slice" + op: "Slice" + input: "gradients_8/filter_type_1/add_7_grad/Reshape" + input: "gradients_8/filter_type_1/concat_2_grad/ConcatOffset" + input: "gradients_8/filter_type_1/concat_2_grad/ShapeN" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/concat_2_grad/Slice_1" + op: "Slice" + input: "gradients_8/filter_type_1/add_7_grad/Reshape" + input: "gradients_8/filter_type_1/concat_2_grad/ConcatOffset:1" + input: "gradients_8/filter_type_1/concat_2_grad/ShapeN:1" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_10_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_10_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_7_grad/Reshape_1" + input: "gradients_8/filter_type_1/Reshape_10_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_1" + input: "gradients_8/filter_type_0/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_4" + input: "gradients_8/filter_type_0/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/Tanh_1_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_1" + input: "gradients_8/filter_type_1/Reshape_3_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/Tanh_4_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_4" + input: "gradients_8/filter_type_1/Reshape_10_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/add_1_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/add_1_grad/Shape" + input: "gradients_8/filter_type_0/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_1_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_0/Tanh_1_grad/TanhGrad" + input: "gradients_8/filter_type_0/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_1_grad/Sum" + input: "gradients_8/filter_type_0/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_6_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/add_6_grad/Shape" + input: "gradients_8/filter_type_0/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_6_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_0/Tanh_4_grad/TanhGrad" + input: "gradients_8/filter_type_0/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_6_grad/Sum" + input: "gradients_8/filter_type_0/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_1_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_1_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/add_1_grad/Shape" + input: "gradients_8/filter_type_1/add_1_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_1_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_1/Tanh_1_grad/TanhGrad" + input: "gradients_8/filter_type_1/add_1_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_1_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_1_grad/Sum" + input: "gradients_8/filter_type_1/add_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_6_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_6_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_6_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/add_6_grad/Shape" + input: "gradients_8/filter_type_1/add_6_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_6_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_1/Tanh_4_grad/TanhGrad" + input: "gradients_8/filter_type_1/add_6_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_6_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_6_grad/Sum" + input: "gradients_8/filter_type_1/add_6_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_8/filter_type_0/add_1_grad/Reshape" + input: "filter_type_0/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_8/filter_type_0/add_6_grad/Reshape" + input: "filter_type_0/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_1_grad/MatMul" + op: "MatMul" + input: "gradients_8/filter_type_1/add_1_grad/Reshape" + input: "filter_type_1/matrix_2_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_5_grad/MatMul" + op: "MatMul" + input: "gradients_8/filter_type_1/add_6_grad/Reshape" + input: "filter_type_1/matrix_2_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/AddN_10" + op: "AddN" + input: "gradients_8/filter_type_0/concat_grad/Slice" + input: "gradients_8/filter_type_0/concat_grad/Slice_1" + input: "gradients_8/filter_type_0/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_0/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_8/AddN_10" + input: "gradients_8/filter_type_0/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_11" + op: "AddN" + input: "gradients_8/filter_type_0/concat_2_grad/Slice" + input: "gradients_8/filter_type_0/concat_2_grad/Slice_1" + input: "gradients_8/filter_type_0/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_0/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_0/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_8/AddN_11" + input: "gradients_8/filter_type_0/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_12" + op: "AddN" + input: "gradients_8/filter_type_1/concat_grad/Slice" + input: "gradients_8/filter_type_1/concat_grad/Slice_1" + input: "gradients_8/filter_type_1/MatMul_1_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_1/concat_grad/Slice" + } + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_2_grad/Reshape" + op: "Reshape" + input: "gradients_8/AddN_12" + input: "gradients_8/filter_type_1/Reshape_2_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_13" + op: "AddN" + input: "gradients_8/filter_type_1/concat_2_grad/Slice" + input: "gradients_8/filter_type_1/concat_2_grad/Slice_1" + input: "gradients_8/filter_type_1/MatMul_5_grad/MatMul" + attr { + key: "N" + value { + i: 3 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_1/concat_2_grad/Slice" + } + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_9_grad/Shape" + op: "Shape" + input: "filter_type_1/Tanh_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_8/AddN_13" + input: "gradients_8/filter_type_1/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh" + input: "gradients_8/filter_type_0/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_0/Tanh_3" + input: "gradients_8/filter_type_0/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/Tanh_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh" + input: "gradients_8/filter_type_1/Reshape_2_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_1/Tanh_3_grad/TanhGrad" + op: "TanhGrad" + input: "filter_type_1/Tanh_3" + input: "gradients_8/filter_type_1/Reshape_9_grad/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } +} +node { + name: "gradients_8/filter_type_0/add_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/add_grad/Shape" + input: "gradients_8/filter_type_0/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_0/Tanh_grad/TanhGrad" + input: "gradients_8/filter_type_0/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_grad/Sum" + input: "gradients_8/filter_type_0/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_5_grad/Shape" + op: "Shape" + input: "filter_type_0/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_0/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_0/add_5_grad/Shape" + input: "gradients_8/filter_type_0/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/add_5_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_0/Tanh_3_grad/TanhGrad" + input: "gradients_8/filter_type_0/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_0/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/add_5_grad/Sum" + input: "gradients_8/filter_type_0/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/add_grad/Shape" + input: "gradients_8/filter_type_1/add_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_1/Tanh_grad/TanhGrad" + input: "gradients_8/filter_type_1/add_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_grad/Sum" + input: "gradients_8/filter_type_1/add_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_5_grad/Shape" + op: "Shape" + input: "filter_type_1/MatMul_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_5_grad/Shape_1" + op: "Shape" + input: "filter_type_1/bias_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_5_grad/BroadcastGradientArgs" + op: "BroadcastGradientArgs" + input: "gradients_8/filter_type_1/add_5_grad/Shape" + input: "gradients_8/filter_type_1/add_5_grad/Shape_1" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/add_5_grad/Sum" + op: "Sum" + input: "gradients_8/filter_type_1/Tanh_3_grad/TanhGrad" + input: "gradients_8/filter_type_1/add_5_grad/BroadcastGradientArgs" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "gradients_8/filter_type_1/add_5_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/add_5_grad/Sum" + input: "gradients_8/filter_type_1/add_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_8/filter_type_0/add_grad/Reshape" + input: "filter_type_0/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_0/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_8/filter_type_0/add_5_grad/Reshape" + input: "filter_type_0/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_grad/MatMul" + op: "MatMul" + input: "gradients_8/filter_type_1/add_grad/Reshape" + input: "filter_type_1/matrix_1_0/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_1/MatMul_4_grad/MatMul" + op: "MatMul" + input: "gradients_8/filter_type_1/add_5_grad/Reshape" + input: "filter_type_1/matrix_1_1/read" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: true + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/MatMul_grad/MatMul" + input: "gradients_8/filter_type_0/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/MatMul_4_grad/MatMul" + input: "gradients_8/filter_type_0/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_1_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/MatMul_grad/MatMul" + input: "gradients_8/filter_type_1/Reshape_1_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_8_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_8_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/MatMul_4_grad/MatMul" + input: "gradients_8/filter_type_1/Reshape_8_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_1_grad/stack" + op: "Pack" + input: "gradients_8/filter_type_0/Slice_1_grad/Rank" + input: "gradients_8/filter_type_0/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_1/begin" + input: "gradients_8/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_1_grad/sub" + op: "Sub" + input: "gradients_8/filter_type_0/Slice_1_grad/Shape_1" + input: "gradients_8/filter_type_0/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_8/filter_type_0/Slice_1_grad/sub" + input: "filter_type_0/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_0/Slice_1_grad/sub_1" + input: "gradients_8/filter_type_0/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_8/filter_type_0/Slice_1_grad/Reshape" + input: "gradients_8/filter_type_0/Slice_1_grad/Reshape_1" + input: "gradients_8/filter_type_0/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 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_8/filter_type_0/Reshape_1_grad/Reshape" + input: "gradients_8/filter_type_0/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_3_grad/stack" + op: "Pack" + input: "gradients_8/filter_type_0/Slice_3_grad/Rank" + input: "gradients_8/filter_type_0/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_3/begin" + input: "gradients_8/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_0/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_3_grad/sub" + op: "Sub" + input: "gradients_8/filter_type_0/Slice_3_grad/Shape_1" + input: "gradients_8/filter_type_0/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_8/filter_type_0/Slice_3_grad/sub" + input: "filter_type_0/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_0/Slice_3_grad/sub_1" + input: "gradients_8/filter_type_0/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_8/filter_type_0/Slice_3_grad/Reshape" + input: "gradients_8/filter_type_0/Slice_3_grad/Reshape_1" + input: "gradients_8/filter_type_0/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 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_8/filter_type_0/Reshape_8_grad/Reshape" + input: "gradients_8/filter_type_0/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_1_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_1_grad/stack" + op: "Pack" + input: "gradients_8/filter_type_1/Slice_1_grad/Rank" + input: "gradients_8/filter_type_1/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_1_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_1/begin" + input: "gradients_8/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_1_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_1_grad/sub" + op: "Sub" + input: "gradients_8/filter_type_1/Slice_1_grad/Shape_1" + input: "gradients_8/filter_type_1/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_8/filter_type_1/Slice_1_grad/sub" + input: "filter_type_1/Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_1/Slice_1_grad/sub_1" + input: "gradients_8/filter_type_1/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_8/filter_type_1/Slice_1_grad/Reshape" + input: "gradients_8/filter_type_1/Slice_1_grad/Reshape_1" + input: "gradients_8/filter_type_1/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 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_8/filter_type_1/Reshape_1_grad/Reshape" + input: "gradients_8/filter_type_1/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_3_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_3_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_3" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_3_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_3_grad/stack" + op: "Pack" + input: "gradients_8/filter_type_1/Slice_3_grad/Rank" + input: "gradients_8/filter_type_1/Slice_3_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_3_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_3/begin" + input: "gradients_8/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_3_grad/Shape_1" + op: "Shape" + input: "filter_type_1/Reshape_7" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_3_grad/sub" + op: "Sub" + input: "gradients_8/filter_type_1/Slice_3_grad/Shape_1" + input: "gradients_8/filter_type_1/Slice_3_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_3_grad/sub_1" + op: "Sub" + input: "gradients_8/filter_type_1/Slice_3_grad/sub" + input: "filter_type_1/Slice_3/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_3_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_1/Slice_3_grad/sub_1" + input: "gradients_8/filter_type_1/Slice_3_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_3_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_3_grad/concat" + op: "ConcatV2" + input: "gradients_8/filter_type_1/Slice_3_grad/Reshape" + input: "gradients_8/filter_type_1/Slice_3_grad/Reshape_1" + input: "gradients_8/filter_type_1/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 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_3_grad/Pad" + op: "Pad" + input: "gradients_8/filter_type_1/Reshape_8_grad/Reshape" + input: "gradients_8/filter_type_1/Slice_3_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/Slice_1_grad/Pad" + input: "gradients_8/filter_type_0/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_0/Slice_3_grad/Pad" + input: "gradients_8/filter_type_0/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/Slice_1_grad/Pad" + input: "gradients_8/filter_type_1/Reshape_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_7_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Reshape_7_grad/Reshape" + op: "Reshape" + input: "gradients_8/filter_type_1/Slice_3_grad/Pad" + input: "gradients_8/filter_type_1/Reshape_7_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_14" + op: "AddN" + input: "gradients_8/filter_type_0/Reshape_6_grad/Reshape" + input: "gradients_8/filter_type_0/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_0/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_grad/stack" + op: "Pack" + input: "gradients_8/filter_type_0/Slice_grad/Rank" + input: "gradients_8/filter_type_0/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice/begin" + input: "gradients_8/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_grad/sub" + op: "Sub" + input: "gradients_8/filter_type_0/Slice_grad/Shape_1" + input: "gradients_8/filter_type_0/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_grad/sub_1" + op: "Sub" + input: "gradients_8/filter_type_0/Slice_grad/sub" + input: "filter_type_0/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_0/Slice_grad/sub_1" + input: "gradients_8/filter_type_0/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_8/filter_type_0/Slice_grad/Reshape" + input: "gradients_8/filter_type_0/Slice_grad/Reshape_1" + input: "gradients_8/filter_type_0/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_grad/Pad" + op: "Pad" + input: "gradients_8/AddN_14" + input: "gradients_8/filter_type_0/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_15" + op: "AddN" + input: "gradients_8/filter_type_0/Reshape_13_grad/Reshape" + input: "gradients_8/filter_type_0/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_0/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_0/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_2_grad/stack" + op: "Pack" + input: "gradients_8/filter_type_0/Slice_2_grad/Rank" + input: "gradients_8/filter_type_0/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_0/Slice_2/begin" + input: "gradients_8/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_5" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_2_grad/sub" + op: "Sub" + input: "gradients_8/filter_type_0/Slice_2_grad/Shape_1" + input: "gradients_8/filter_type_0/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_8/filter_type_0/Slice_2_grad/sub" + input: "filter_type_0/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_0/Slice_2_grad/sub_1" + input: "gradients_8/filter_type_0/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_8/filter_type_0/Slice_2_grad/Reshape" + input: "gradients_8/filter_type_0/Slice_2_grad/Reshape_1" + input: "gradients_8/filter_type_0/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 + } + } +} +node { + name: "gradients_8/filter_type_0/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_8/AddN_15" + input: "gradients_8/filter_type_0/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_16" + op: "AddN" + input: "gradients_8/filter_type_1/Reshape_6_grad/Reshape" + input: "gradients_8/filter_type_1/Reshape_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_1/Reshape_6_grad/Reshape" + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_grad/stack" + op: "Pack" + input: "gradients_8/filter_type_1/Slice_grad/Rank" + input: "gradients_8/filter_type_1/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice/begin" + input: "gradients_8/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_grad/sub" + op: "Sub" + input: "gradients_8/filter_type_1/Slice_grad/Shape_1" + input: "gradients_8/filter_type_1/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_grad/sub_1" + op: "Sub" + input: "gradients_8/filter_type_1/Slice_grad/sub" + input: "filter_type_1/Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_1/Slice_grad/sub_1" + input: "gradients_8/filter_type_1/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_8/filter_type_1/Slice_grad/Reshape" + input: "gradients_8/filter_type_1/Slice_grad/Reshape_1" + input: "gradients_8/filter_type_1/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_grad/Pad" + op: "Pad" + input: "gradients_8/AddN_16" + input: "gradients_8/filter_type_1/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_17" + op: "AddN" + input: "gradients_8/filter_type_1/Reshape_13_grad/Reshape" + input: "gradients_8/filter_type_1/Reshape_7_grad/Reshape" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_1/Reshape_13_grad/Reshape" + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_2_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_2_grad/Shape" + op: "Shape" + input: "filter_type_1/Slice_2" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_2_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_2_grad/stack" + op: "Pack" + input: "gradients_8/filter_type_1/Slice_2_grad/Rank" + input: "gradients_8/filter_type_1/Slice_2_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_2_grad/Reshape" + op: "Reshape" + input: "filter_type_1/Slice_2/begin" + input: "gradients_8/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_2_grad/Shape_1" + op: "Shape" + input: "Reshape_9" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_2_grad/sub" + op: "Sub" + input: "gradients_8/filter_type_1/Slice_2_grad/Shape_1" + input: "gradients_8/filter_type_1/Slice_2_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_2_grad/sub_1" + op: "Sub" + input: "gradients_8/filter_type_1/Slice_2_grad/sub" + input: "filter_type_1/Slice_2/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_2_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/filter_type_1/Slice_2_grad/sub_1" + input: "gradients_8/filter_type_1/Slice_2_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_2_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_2_grad/concat" + op: "ConcatV2" + input: "gradients_8/filter_type_1/Slice_2_grad/Reshape" + input: "gradients_8/filter_type_1/Slice_2_grad/Reshape_1" + input: "gradients_8/filter_type_1/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 + } + } +} +node { + name: "gradients_8/filter_type_1/Slice_2_grad/Pad" + op: "Pad" + input: "gradients_8/AddN_17" + input: "gradients_8/filter_type_1/Slice_2_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_18" + op: "AddN" + input: "gradients_8/filter_type_0/Slice_grad/Pad" + input: "gradients_8/filter_type_0/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_0/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_8/Reshape_5_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_5_grad/Reshape" + op: "Reshape" + input: "gradients_8/AddN_18" + input: "gradients_8/Reshape_5_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_19" + op: "AddN" + input: "gradients_8/filter_type_1/Slice_grad/Pad" + input: "gradients_8/filter_type_1/Slice_2_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/filter_type_1/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_8/Reshape_9_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_9_grad/Reshape" + op: "Reshape" + input: "gradients_8/AddN_19" + input: "gradients_8/Reshape_9_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/Slice_grad/Shape" + op: "Shape" + input: "Slice" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/Slice_grad/stack" + op: "Pack" + input: "gradients_8/Slice_grad/Rank" + input: "gradients_8/Slice_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/Slice_grad/Reshape" + op: "Reshape" + input: "Slice/begin" + input: "gradients_8/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_grad/sub" + op: "Sub" + input: "gradients_8/Slice_grad/Shape_1" + input: "gradients_8/Slice_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_grad/sub_1" + op: "Sub" + input: "gradients_8/Slice_grad/sub" + input: "Slice/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/Slice_grad/sub_1" + input: "gradients_8/Slice_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/Slice_grad/concat" + op: "ConcatV2" + input: "gradients_8/Slice_grad/Reshape" + input: "gradients_8/Slice_grad/Reshape_1" + input: "gradients_8/Slice_grad/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_grad/Pad" + op: "Pad" + input: "gradients_8/Reshape_5_grad/Reshape" + input: "gradients_8/Slice_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_1_grad/Rank" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "gradients_8/Slice_1_grad/Shape" + op: "Shape" + input: "Slice_1" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_1_grad/stack/1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/Slice_1_grad/stack" + op: "Pack" + input: "gradients_8/Slice_1_grad/Rank" + input: "gradients_8/Slice_1_grad/stack/1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "gradients_8/Slice_1_grad/Reshape" + op: "Reshape" + input: "Slice_1/begin" + input: "gradients_8/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_1_grad/Shape_1" + op: "Shape" + input: "Reshape_4" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_1_grad/sub" + op: "Sub" + input: "gradients_8/Slice_1_grad/Shape_1" + input: "gradients_8/Slice_1_grad/Shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_1_grad/sub_1" + op: "Sub" + input: "gradients_8/Slice_1_grad/sub" + input: "Slice_1/begin" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_1_grad/Reshape_1" + op: "Reshape" + input: "gradients_8/Slice_1_grad/sub_1" + input: "gradients_8/Slice_1_grad/stack" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Slice_1_grad/concat/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "gradients_8/Slice_1_grad/concat" + op: "ConcatV2" + input: "gradients_8/Slice_1_grad/Reshape" + input: "gradients_8/Slice_1_grad/Reshape_1" + input: "gradients_8/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 + } + } +} +node { + name: "gradients_8/Slice_1_grad/Pad" + op: "Pad" + input: "gradients_8/Reshape_9_grad/Reshape" + input: "gradients_8/Slice_1_grad/concat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tpaddings" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/AddN_20" + op: "AddN" + input: "gradients_8/Slice_grad/Pad" + input: "gradients_8/Slice_1_grad/Pad" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@gradients_8/Slice_grad/Pad" + } + } + } +} +node { + name: "gradients_8/Reshape_4_grad/Shape" + op: "Shape" + input: "o_rmat" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "gradients_8/Reshape_4_grad/Reshape" + op: "Reshape" + input: "gradients_8/AddN_20" + input: "gradients_8/Reshape_4_grad/Shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_58/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "strided_slice_58/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_58/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_58" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_58/stack" + input: "strided_slice_58/stack_1" + input: "strided_slice_58/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_47/y" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 552 + } + } + } +} +node { + name: "mul_47" + op: "Mul" + input: "strided_slice_58" + input: "mul_47/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_55/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_55/shape" + op: "Pack" + input: "Reshape_55/shape/0" + input: "mul_47" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_55" + op: "Reshape" + input: "gradients_8/Reshape_4_grad/Reshape" + input: "Reshape_55/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "ProdForceSeA_8" + op: "ProdForceSeA" + input: "Reshape_55" + input: "o_rmat_deriv" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "ProdVirialSeA_8" + op: "ProdVirialSeA" + input: "Reshape_55" + input: "o_rmat_deriv" + input: "o_rij" + input: "o_nlist" + input: "t_natoms" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "n_a_sel" + value { + i: 138 + } + } + attr { + key: "n_r_sel" + value { + i: 0 + } + } +} +node { + name: "strided_slice_59/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_59/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_59/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_59" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_59/stack" + input: "strided_slice_59/stack_1" + input: "strided_slice_59/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_48/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "mul_48" + op: "Mul" + input: "mul_48/x" + input: "strided_slice_59" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_56/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_56/shape" + op: "Pack" + input: "Reshape_56/shape/0" + input: "mul_48" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_56" + op: "Reshape" + input: "ProdForceSeA_8" + input: "Reshape_56/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_57/shape" + op: "Const" + 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\t\000\000\000" + } + } + } +} +node { + name: "Reshape_57" + op: "Reshape" + input: "ProdVirialSeA_8" + input: "Reshape_57/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "strided_slice_60/stack" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_60/stack_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "strided_slice_60/stack_2" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "strided_slice_60" + op: "StridedSlice" + input: "t_natoms" + input: "strided_slice_60/stack" + input: "strided_slice_60/stack_1" + input: "strided_slice_60/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "mul_49/x" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 9 + } + } + } +} +node { + name: "mul_49" + op: "Mul" + input: "mul_49/x" + input: "strided_slice_60" + attr { + key: "T" + value { + type: DT_INT32 + } + } +} +node { + name: "Reshape_58/shape/0" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "Reshape_58/shape" + op: "Pack" + input: "Reshape_58/shape/0" + input: "mul_49" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "Reshape_58" + op: "Reshape" + input: "ProdVirialSeA_8:1" + input: "Reshape_58/shape" + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } +} +node { + name: "o_force/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "o_force" + op: "ConcatV2" + input: "Reshape_24" + input: "Reshape_28" + input: "Reshape_32" + input: "Reshape_36" + input: "Reshape_40" + input: "Reshape_44" + input: "Reshape_48" + input: "Reshape_52" + input: "Reshape_56" + input: "o_force/axis" + attr { + key: "N" + value { + i: 9 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "o_virial/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "o_virial" + op: "ConcatV2" + input: "Reshape_25" + input: "Reshape_29" + input: "Reshape_33" + input: "Reshape_37" + input: "Reshape_41" + input: "Reshape_45" + input: "Reshape_49" + input: "Reshape_53" + input: "Reshape_57" + input: "o_virial/axis" + attr { + key: "N" + value { + i: 9 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +node { + name: "o_atom_virial/axis" + op: "Const" + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "o_atom_virial" + op: "ConcatV2" + input: "Reshape_26" + input: "Reshape_30" + input: "Reshape_34" + input: "Reshape_38" + input: "Reshape_42" + input: "Reshape_46" + input: "Reshape_50" + input: "Reshape_54" + input: "Reshape_58" + input: "o_atom_virial/axis" + attr { + key: "N" + value { + i: 9 + } + } + attr { + key: "T" + value { + type: DT_DOUBLE + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } +} +library { +} +versions { +} diff --git a/source/tests/test_deepdipole.py b/source/tests/test_deepdipole.py index 2856b4f319..84049a9e52 100644 --- a/source/tests/test_deepdipole.py +++ b/source/tests/test_deepdipole.py @@ -4,7 +4,8 @@ from infer.convert2pb import convert_pbtxt_to_pb from deepmd.infer import DeepDipole -from common import tests_path +from common import tests_path, finite_difference, strerch_box, tf +from packaging.version import parse as parse_version from deepmd.env import GLOBAL_NP_FLOAT_PRECISION if GLOBAL_NP_FLOAT_PRECISION == np.float32 : @@ -61,3 +62,295 @@ def test_2frame_atm(self): self.assertAlmostEqual(dd.reshape([-1])[ii], expected_d.reshape([-1])[ii], places = default_places) +class TestDeepDipoleNoPBC(unittest.TestCase) : + def setUp(self): + convert_pbtxt_to_pb(str(tests_path / os.path.join("infer","deepdipole.pbtxt")), "deepdipole.pb") + self.dp = DeepDipole("deepdipole.pb") + self.coords = np.array([12.83, 2.56, 2.18, + 12.09, 2.87, 2.74, + 00.25, 3.32, 1.68, + 3.36, 3.00, 1.81, + 3.51, 2.51, 2.60, + 4.27, 3.22, 1.56]) + self.atype = [0, 1, 1, 0, 1, 1] + self.box = np.array([20., 0., 0., 0., 20., 0., 0., 0., 20.]) + self.expected_d = np.array([-1.982092647058316e+00, 8.303361089028074e-01, 1.499962003179265e+00, 2.927112547154802e+00, -8.572096473802318e-01, 1.667798310054391e+00]) + + def tearDown(self): + os.remove("deepdipole.pb") + + def test_1frame_atm(self): + dd = self.dp.eval(self.coords, None, self.atype) + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + nsel = 2 + self.assertEqual(dd.shape, (nframes,nsel,3)) + # check values + for ii in range(dd.size): + self.assertAlmostEqual(dd.reshape([-1])[ii], self.expected_d.reshape([-1])[ii], places = default_places) + + def test_1frame_atm_large_box(self): + dd = self.dp.eval(self.coords, self.box, self.atype) + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + nsel = 2 + self.assertEqual(dd.shape, (nframes,nsel,3)) + # check values + for ii in range(dd.size): + self.assertAlmostEqual(dd.reshape([-1])[ii], self.expected_d.reshape([-1])[ii], places = default_places) + + +@unittest.skipIf(parse_version(tf.__version__) < parse_version("1.15"), + f"The current tf version {tf.__version__} is too low to run the new testing model.") +class TestDeepDipoleNewPBC(unittest.TestCase) : + def setUp(self): + convert_pbtxt_to_pb(str(tests_path / os.path.join("infer","deepdipole_new.pbtxt")), "deepdipole_new.pb") + self.dp = DeepDipole("deepdipole_new.pb") + self.coords = np.array([12.83, 2.56, 2.18, + 12.09, 2.87, 2.74, + 00.25, 3.32, 1.68, + 3.36, 3.00, 1.81, + 3.51, 2.51, 2.60, + 4.27, 3.22, 1.56]) + self.nout = 3 + self.atype = np.array([0, 1, 1, 0, 1, 1]) + self.box = np.array([13., 0., 0., 0., 13., 0., 0., 0., 13.]) + self.expected_t = np.array([-1.128427726201255282e-01, 2.654103846999197880e-01, 2.625816377288122533e-02, 3.027556488877700680e-01, -7.475444785689989990e-02, 1.526291164572509684e-01]) + self.expected_f = np.array([8.424897862241968738e-02, -3.823566783202275721e-02, 3.570797165027734810e-01, 6.102563129736437997e-02, -1.351209759852018133e-01, -2.438224487466488510e-01, -1.403204771681088869e-01, 1.719596545791735875e-01, -1.136584427103610045e-01, 2.761686212947551955e-02, -7.247860200915196005e-02, 6.208831127377397591e-02, -2.605870723577520809e-01, -4.504074577536486268e-02, 7.340240097998475266e-02, 2.280160774766013809e-01, 1.189163370225677641e-01, -1.350895372995223886e-01, -4.294311497114180337e-02, 1.524802094783661577e-01, 1.070451777645946290e-01, -1.259336332521076574e-01, -2.087610788959351760e-01, 9.447141346538817652e-02, 1.668125597515543457e-01, 5.487037060760904805e-02, -2.014994036104674757e-01, -7.411985441205551361e-02, 3.614456658821710300e-01, 2.901174891391154476e-01, -4.871926969937838414e-02, -1.252747945819455699e-01, -2.555459318266457558e-01, 1.249033125831290059e-01, -2.347603724902655176e-01, -3.458874493198500766e-02, 3.563990394229877290e-01, 1.052342031228763047e-01, 1.907268232932498031e-01, -2.432737821373903708e-01, 1.016781829972335099e-01, -7.707616437996064884e-02, -1.139199805053340564e-01, -2.068592154909300040e-01, -1.156337826476897951e-01, 6.583817133933017596e-02, 2.902207490750204344e-01, 9.945482314729316153e-02, 7.986986504051810098e-02, -2.549975565538568079e-01, 1.275343199697696051e-01, -1.449133131601115787e-01, -3.527636315034351350e-02, -2.250060193826620980e-01]) + self.expected_v = np.array([3.479789535931299138e-02, 4.337414719007849292e-03, -3.647371468256610082e-03, 8.053492919528318708e-03, 1.003834811499279773e-03, -8.441338187607602033e-04, -6.695998268698949256e-03, -8.346286793845711892e-04, 7.018468440279366279e-04, -4.515896716004976635e-02, 1.891794570218296306e-02, 3.417435352652402336e-02, 9.998952222904963771e-02, -4.188750255541257711e-02, -7.566774655171297492e-02, 1.804286120725206444e-01, -7.558495911146115298e-02, -1.365405712981232755e-01, -1.002593446510361419e-01, -1.117945222697993429e-01, 7.449172735713084637e-02, 7.770237313970995707e-02, 1.313723119887387492e-01, -8.655414676270002661e-02, -4.973937467461287537e-02, -8.663006083493235421e-02, 5.703914957966123994e-02, -3.382231967662072125e-02, -4.215813217482468345e-03, 3.545115660155720612e-03, -8.247565860499378454e-03, -1.028025206407854253e-03, 8.644757417520612143e-04, 6.761330949063471332e-03, 8.427721296283078580e-04, -7.086947453692606178e-04, -1.622698090933780493e-02, 1.305372051650728060e-01, -2.082599910094798112e-01, -7.109985131471197733e-03, 2.202585658101286273e-02, -3.554509763049529952e-02, 1.436400379134906459e-02, -3.554915857551419617e-02, 5.763638171798115412e-02, 2.074946305037073946e-01, 5.016353704485233822e-02, -5.700401936915034523e-02, 1.082138666905367308e-01, 2.616159414496492877e-02, -2.972908425564194101e-02, -1.229314789425654392e-01, -2.971969820589494271e-02, 3.377238432488059716e-02, 7.622024445219390681e-03, 9.500540384976005961e-04, -7.989090778275298932e-04, -2.952148931042387209e-02, -3.679732378636401541e-03, 3.094320409307891630e-03, -9.534268115386618486e-04, -1.188407357158671420e-04, 9.993425503379762414e-05, 9.319088860655992679e-02, -3.903942630815338682e-02, -7.052283462118023871e-02, 1.544831983829924038e-01, -6.471593445773991815e-02, -1.169062041817236081e-01, -6.990884596438741438e-02, 2.928613817427033750e-02, 5.290399154061733306e-02, 7.491400658274136037e-02, 1.273824184577304897e-01, -8.391492311946648075e-02, 3.543872837542783732e-02, 4.324623973455964804e-02, -2.873418641045778418e-02, -8.444981234074398768e-02, -1.531171183141288306e-01, 1.007308415346981068e-01, -6.396885751015785743e-03, -7.973455327045167592e-04, 6.704951070469818575e-04, 2.915483242551994078e-02, 3.634030104030812076e-03, -3.055888951116827318e-03, 6.608747470375698129e-04, 8.237532257692081912e-05, -6.927015762150179410e-05, -6.099175331115514430e-03, 2.402310352789886402e-02, -3.861491558256636286e-02, -2.583867422346154685e-02, 6.050621302336450097e-02, -9.822840263095998503e-02, -3.827994718203701213e-02, 1.252239810257823327e-01, -2.018867305507059950e-01, 1.136620144506474833e-01, 2.747872876828840599e-02, -3.122582814578225147e-02, -2.136319389661417989e-01, -5.164728194785846160e-02, 5.869009312256637939e-02, -3.147575788810638014e-02, -7.609523885036708832e-03, 8.647186232996251914e-03, -5.990706138603461330e-03, -7.467169124604876177e-04, 6.279210400235934152e-04, -9.287887182821588476e-04, -1.157696985960763821e-04, 9.735179200124630735e-05, -2.966271471326579340e-02, -3.697335544996301071e-03, 3.109123071928715683e-03, 1.800225987816693740e-01, -7.541487246259104271e-02, -1.362333179969384966e-01, -7.524185541795300192e-02, 3.152023672914239238e-02, 5.693978247845072477e-02, 5.703636164117102669e-02, -2.389361095778780308e-02, -4.316265205277792366e-02, -4.915584336537091176e-02, -8.674240294138457763e-02, 5.709724154860432860e-02, -8.679070528401405804e-02, -1.572017650485294793e-01, 1.034201569997979520e-01, -3.557746655862283752e-02, -8.626268394893003844e-02, 5.645546718878535764e-02, 6.848075985139651621e-03, 8.535845420570665554e-04, -7.177870012752625602e-04, 8.266638576582277997e-04, 1.030402542123569647e-04, -8.664748649675494882e-05, 2.991751925173294011e-02, 3.729095884068693231e-03, -3.135830629785046203e-03, 1.523793442834292522e-02, -3.873020552543556677e-02, 6.275576045602117292e-02, -3.842536616563556329e-02, 1.249268983543572881e-01, -2.014296501045876875e-01, 1.288704808602599873e-02, -6.326999354443738066e-02, 1.014064886873057153e-01, -1.318711149757016143e-01, -3.188092889522457091e-02, 3.622832829002789468e-02, -3.210149046681261276e-02, -7.760799893075580151e-03, 8.819090787585878374e-03, -2.047554776382226327e-01, -4.950132426418570042e-02, 5.625150484566552450e-02]) + self.expected_gt = self.expected_t.reshape(-1, self.nout).sum(0).reshape(-1) + self.expected_gv = self.expected_v.reshape(1, self.nout, 6, 9).sum(-2).reshape(-1) + + def tearDown(self): + os.remove("deepdipole_new.pb") + + def test_attrs(self): + self.assertEqual(self.dp.get_ntypes(), 2) + self.assertAlmostEqual(self.dp.get_rcut(), 4.0, places = default_places) + self.assertEqual(self.dp.get_type_map(), ['O', 'H']) + self.assertEqual(self.dp.get_sel_type(), [0]) + + def test_1frame_old(self): + gt = self.dp.eval(self.coords, self.box, self.atype, atomic=False) + # check shape of the returns + nframes = 1 + self.assertEqual(gt.shape, (nframes,self.nout)) + # check values + for ii in range(gt.size): + self.assertAlmostEqual(gt.reshape([-1])[ii], self.expected_gt.reshape([-1])[ii], places = default_places) + + def test_1frame_old_atm(self): + at = self.dp.eval(self.coords, self.box, self.atype) + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + nsel = 2 + self.assertEqual(at.shape, (nframes,nsel,self.nout)) + # check values + for ii in range(at.size): + self.assertAlmostEqual(at.reshape([-1])[ii], self.expected_t.reshape([-1])[ii], places = default_places) + + def test_2frame_old_atm(self): + coords2 = np.concatenate((self.coords, self.coords)) + box2 = np.concatenate((self.box, self.box)) + at = self.dp.eval(coords2, box2, self.atype) + # check shape of the returns + nframes = 2 + natoms = len(self.atype) + nsel = 2 + self.assertEqual(at.shape, (nframes,nsel,self.nout)) + # check values + expected_d = np.concatenate((self.expected_t, self.expected_t)) + for ii in range(at.size): + self.assertAlmostEqual(at.reshape([-1])[ii], expected_d.reshape([-1])[ii], places = default_places) + + def test_1frame_full(self): + gt, ff, vv = self.dp.eval_full(self.coords, self.box, self.atype, atomic = False) + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + self.assertEqual(gt.shape, (nframes,self.nout)) + self.assertEqual(ff.shape, (nframes,self.nout,natoms,3)) + self.assertEqual(vv.shape, (nframes,self.nout,9)) + # check values + for ii in range(ff.size): + self.assertAlmostEqual(ff.reshape([-1])[ii], self.expected_f.reshape([-1])[ii], places = default_places) + for ii in range(gt.size): + self.assertAlmostEqual(gt.reshape([-1])[ii], self.expected_gt.reshape([-1])[ii], places = default_places) + for ii in range(vv.size): + self.assertAlmostEqual(vv.reshape([-1])[ii], self.expected_gv.reshape([-1])[ii], places = default_places) + + def test_1frame_full_atm(self): + gt, ff, vv, at, av = self.dp.eval_full(self.coords, self.box, self.atype, atomic = True) + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + nsel = 2 + self.assertEqual(gt.shape, (nframes,self.nout)) + self.assertEqual(ff.shape, (nframes,self.nout,natoms,3)) + self.assertEqual(vv.shape, (nframes,self.nout,9)) + self.assertEqual(at.shape, (nframes,nsel,self.nout)) + self.assertEqual(av.shape, (nframes,self.nout,natoms,9)) + # check values + np.testing.assert_almost_equal(ff.reshape([-1]), self.expected_f.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(at.reshape([-1]), self.expected_t.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(av.reshape([-1]), self.expected_v.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(gt.reshape([-1]), self.expected_gt.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(vv.reshape([-1]), self.expected_gv.reshape([-1]), decimal = default_places) + + def test_1frame_full_atm_shuffle(self): + i_sf = [2,1,3,0,5,4] + isel_sf = [1,0] + gt, ff, vv, at, av = self.dp.eval_full(self.coords.reshape(-1,3)[i_sf].reshape(-1), self.box, self.atype[i_sf], atomic = True) + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + nsel = 2 + self.assertEqual(gt.shape, (nframes,self.nout)) + self.assertEqual(ff.shape, (nframes,self.nout,natoms,3)) + self.assertEqual(vv.shape, (nframes,self.nout,9)) + self.assertEqual(at.shape, (nframes,nsel,self.nout)) + self.assertEqual(av.shape, (nframes,self.nout,natoms,9)) + # recover the shuffled result + nff = np.empty_like(ff) + nav = np.empty_like(av) + nat = np.empty_like(at) + nff[:, :, i_sf] = ff + nav[:, :, i_sf] = av + nat[:, isel_sf] = at + # check values + np.testing.assert_almost_equal(nff.reshape([-1]), self.expected_f.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(nat.reshape([-1]), self.expected_t.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(nav.reshape([-1]), self.expected_v.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(gt.reshape([-1]), self.expected_gt.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(vv.reshape([-1]), self.expected_gv.reshape([-1]), decimal = default_places) + + def test_1frame_num_deriv(self): + # numerical force + num_f = - finite_difference( + lambda coord: self.dp.eval(coord, self.box, self.atype, atomic=False).reshape(-1), + self.coords + ).reshape(-1) + np.testing.assert_allclose(num_f.reshape([-1]), self.expected_f.reshape([-1]), atol=1e-5) + # numerical virial + num_v = - (finite_difference( + lambda box: self.dp.eval(strerch_box(self.coords, self.box, box), box, self.atype, atomic=False).reshape(-1), + self.box + ).reshape(-1, 3, 3).transpose(0,2,1) @ self.box.reshape(3,3)).reshape(-1) + np.testing.assert_allclose(num_v.reshape([-1]), self.expected_gv.reshape([-1]), atol=1e-5) + + def test_2frame_full_atm(self): + coords2 = np.concatenate((self.coords, self.coords)) + box2 = np.concatenate((self.box, self.box)) + gt, ff, vv, at, av = self.dp.eval_full(coords2, box2, self.atype, atomic = True) + # check shape of the returns + nframes = 2 + natoms = len(self.atype) + nsel = 2 + self.assertEqual(gt.shape, (nframes,self.nout)) + self.assertEqual(ff.shape, (nframes,self.nout,natoms,3)) + self.assertEqual(vv.shape, (nframes,self.nout,9)) + self.assertEqual(at.shape, (nframes,nsel,self.nout)) + self.assertEqual(av.shape, (nframes,self.nout,natoms,9)) + # check values + expected_f = np.tile(self.expected_f.reshape(-1), nframes) + expected_t = np.tile(self.expected_t.reshape(-1), nframes) + expected_v = np.tile(self.expected_v.reshape(-1), nframes) + expected_gt = np.tile(self.expected_gt.reshape(-1), nframes) + expected_gv = np.tile(self.expected_gv.reshape(-1), nframes) + np.testing.assert_almost_equal(ff.reshape([-1]), expected_f.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(at.reshape([-1]), expected_t.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(av.reshape([-1]), expected_v.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(gt.reshape([-1]), expected_gt.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(vv.reshape([-1]), expected_gv.reshape([-1]), decimal = default_places) + + +@unittest.skipIf(parse_version(tf.__version__) < parse_version("1.15"), + f"The current tf version {tf.__version__} is too low to run the new testing model.") +class TestDeepDipoleFakePBC(unittest.TestCase) : + def setUp(self): + convert_pbtxt_to_pb(str(tests_path / os.path.join("infer","deepdipole_fake.pbtxt")), "deepdipole_fake.pb") + self.dp = DeepDipole("deepdipole_fake.pb") + self.coords = np.array([12.83, 2.56, 2.18, + 12.09, 2.87, 2.74, + 00.25, 3.32, 1.68, + 3.36, 3.00, 1.81, + 3.51, 2.51, 2.60, + 4.27, 3.22, 1.56]) + self.nout = 3 + self.atype = np.array([0, 1, 1, 0, 1, 1]) + self.box = np.array([13., 0., 0., 0., 13., 0., 0., 0., 13.]) + self.expected_t = np.array([-3.186217894664857830e-01, 1.082220317383403296e+00, 5.646623185237639730e-02, 7.426508038929955369e-01, -3.115996324658170114e-01, -5.619108089573777720e-01, -4.181578166874897473e-01, -7.579762930974662805e-01, 4.980618433125854616e-01, 1.059635561913792712e+00, -2.641989315855929332e-01, 5.307984468104405273e-01, -1.484512535335152095e-01, 4.978588497891502374e-01, -8.022467807199461509e-01, -9.165936539882671985e-01, -2.238112120606238209e-01, 2.553133145814526217e-01]) + self.expected_f = np.array([5.041930370187270860e-01, 7.873825190365474347e-03, -4.096376607074713183e-01, -3.904160887819057568e-01, 1.651276463640535541e-01, 2.941164542146633698e-01, -1.137769482368212182e-01, -1.730014715544191672e-01, 1.155212064928080040e-01, 5.863332521864410563e-01, 8.527372103998451247e-02, -6.934420009023331555e-02, -1.225415636916203990e-02, 4.321720022314819165e-02, -7.184309080594213082e-02, -5.740790958172790059e-01, -1.284909212631327180e-01, 1.411872908961754325e-01, 1.394536521676267848e-02, 4.089695733795025712e-01, -8.790828175074971718e-02, 1.594305121314434359e-01, -7.202915091075953735e-02, -1.198685751141350120e-01, -1.733758773482060866e-01, -3.369404224687432281e-01, 2.077768568648848124e-01, 8.892382475507179529e-02, 1.801380487829997712e-01, -3.123469659869602677e-01, 5.864597608298829229e-02, -1.422803757045815187e-01, 2.644907470171818931e-01, -1.475698008380600668e-01, -3.785767307841875901e-02, 4.785621896977837464e-02, -4.108193580732780736e-01, -8.281856742888188405e-02, 3.778676259248315294e-01, 2.952252813797733855e-01, -1.246444286160888204e-01, -2.244502796339041817e-01, 1.155940766935046465e-01, 2.074629960449706489e-01, -1.534173462909272645e-01, -7.510936703550785687e-02, -3.127379668651892319e-01, 4.622598362029770591e-01, -9.621211578064041425e-02, 2.628380090727049923e-01, -4.042471768183623637e-01, 1.713214828161482572e-01, 4.989995779248418417e-02, -5.801265938461462601e-02]) + self.expected_v = np.array([-2.222884841673062051e-01, 9.787686675884660348e-01, -4.154378405125468132e-03, -1.028716279506487613e-01, -5.106807648068932559e-02, 9.617563369584695987e-02, -6.539114125439839109e-02, 8.616465014722822502e-02, 3.804663842399232110e-02, 8.958556637777052023e-01, -3.880568178324209083e-01, -6.754602069672590581e-01, -7.079186190294968484e-02, 2.747611091693637556e-02, 5.399649908930042458e-02, -1.139876669236737639e-01, 5.825425892149401624e-02, 8.421681390884694363e-02, -4.324455921712526130e-01, -7.982113179384198176e-01, 5.178700497729279428e-01, -2.119158650865729521e-02, -5.669958244474895825e-02, 2.880008495593230911e-02, 1.025153878619989092e-02, 3.455330867235743841e-02, -1.531884121903195027e-02, 8.219378927727334361e-01, -3.289162383259068290e-01, 6.075540959886343018e-01, -4.581331025027536585e-02, -2.052131009092891811e-02, 2.750489901219354411e-02, 4.633180549151136307e-02, 2.654757883635484872e-02, -3.696756527480526966e-02, -1.440158444262530923e-01, 4.944364353401542456e-01, -7.963661150769665298e-01, -3.279405043326523786e-03, -2.129463233078606257e-02, 3.328257760760894995e-02, 5.297895300667846037e-03, 3.437606177524311912e-02, -5.372785779467447592e-02, -1.202172148995579004e+00, -2.858130614731594910e-01, 3.226510095110137200e-01, -6.135144302237673097e-02, -7.628488365516866883e-03, 5.476841872267750738e-03, 6.607427030244909794e-02, 5.340677880472323794e-03, -1.357441391258333270e-03, -8.118660176947067875e-02, -5.001362994997625433e-02, 7.779205646059993151e-02, -3.756939173800121767e-01, 9.298080515606454988e-01, 1.339730913665280465e-01, 7.808446283301898050e-02, 6.915261247137938216e-02, -7.891656263643208324e-02, -8.035264423283335067e-02, 3.669461691293440797e-02, 6.021702408564724718e-02, 7.758956893285878786e-01, -3.211906986558734078e-01, -5.879129815844135187e-01, 6.104269012391384808e-02, -2.900814613392431462e-02, -4.552568262646729258e-02, -2.925720146121059406e-02, -6.902319498684716947e-02, 3.795994492146410881e-02, -4.884151777114849047e-01, -8.870211107633522163e-01, 5.820737769422319463e-01, 3.684187251077851444e-02, 8.060668659447538242e-02, -4.657258523345865486e-02, -5.368793987058780026e-02, -2.898503185606490784e-02, 4.002941486858704184e-02, 1.047195951770644173e+00, -2.548621413845133521e-01, 5.147188892651490821e-01, 2.224026955228448205e-02, -3.359454269630585826e-02, 5.544338676867385796e-02, -1.191273887309037081e-03, -2.572624454332552921e-02, 4.050578204667463350e-02, -1.732938335087045867e-01, 5.389208482414027390e-01, -8.697634229876662904e-01, 4.437234466680844980e-02, -8.396020718207411471e-02, 1.373643808601548444e-01, -7.061240859228964939e-02, -6.490608065647092938e-03, 2.687574399814150403e-03, -9.296946571189880215e-01, -2.226700108388965371e-01, 2.521074551855023715e-01, 1.661015709598279849e-02, -1.517347986687963592e-03, 4.175867772300452530e-03, -6.961167479355900856e-02, 8.595942434252096254e-02, 4.162461447266577186e-02, 9.626281426355881576e-02, 7.003654498037747977e-02, -9.432734078079299533e-02, -2.845586320234831934e-01, 9.840080473993093602e-01, 4.702636003956783828e-02, -1.121268620463006793e-01, 5.646007092227271762e-02, 8.300611975708871437e-02, 5.302797712834559501e-02, -2.128036013727904047e-02, -4.031107561971148529e-02, 8.271174343351145319e-01, -3.553740248929939671e-01, -6.241986194331364812e-01, 1.182134083009860406e-02, 3.695184024999947914e-02, -1.710161500383376373e-02, 3.008054412288880750e-02, 7.027591928009153943e-02, -3.889396164699072955e-02, -4.409008808247306677e-01, -8.148107923739302816e-01, 5.281887759440460073e-01, 5.876941218352332852e-02, 3.991562883248954419e-02, -5.674944832716710685e-02, 2.308380369202570059e-02, -3.268790472062921282e-02, 5.410175456271631989e-02, 1.034753757966884624e+00, -2.182612858207719775e-01, 4.555767475016349599e-01, 1.999790463725661591e-03, 4.137558459329451765e-02, -6.513656908661276390e-02, 4.414866304579422029e-02, -8.348549073500094453e-02, 1.365906277014072301e-01, -2.146360657075572775e-01, 6.238014307983194007e-01, -1.008256906299115352e+00, 8.070152934834977365e-02, 3.543449526282398468e-03, 3.048075243036858784e-03, 1.760219621424649605e-02, -1.639238275648761956e-03, 4.474655455192242531e-03, -9.335462888220811273e-01, -2.202218134011651174e-01, 2.478280539571276475e-01]) + self.expected_gt = self.expected_t.reshape(-1, self.nout).sum(0).reshape(-1) + self.expected_gv = self.expected_v.reshape(1, self.nout, 6, 9).sum(-2).reshape(-1) + mcoord = self.coords.reshape(2,3,3) + fake_target = np.stack([ + mcoord[:, 1] + mcoord[:, 2] - 2 * mcoord[:, 0], + mcoord[:, 0] - mcoord[:, 1], + mcoord[:, 0] - mcoord[:, 2] + ], axis=-2) + fake_target = fake_target - 13 * np.rint(fake_target / 13) + self.target_t = fake_target.reshape(-1) + + def tearDown(self): + os.remove("deepdipole_fake.pb") + + def test_attrs(self): + self.assertEqual(self.dp.get_ntypes(), 2) + self.assertAlmostEqual(self.dp.get_rcut(), 2.0, places = default_places) + self.assertEqual(self.dp.get_type_map(), ['O', 'H']) + self.assertEqual(self.dp.get_sel_type().tolist(), [0, 1]) + np.testing.assert_allclose(self.target_t, self.expected_t, atol=3e-2) + + def test_1frame_full_atm(self): + gt, ff, vv, at, av = self.dp.eval_full(self.coords, self.box, self.atype, atomic = True) + for dd in at, ff, av: + print("\n\n") + print(", ".join(f"{ii:.18e}" for ii in dd.reshape(-1))) + print("\n\n") + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + nsel = natoms + self.assertEqual(gt.shape, (nframes,self.nout)) + self.assertEqual(ff.shape, (nframes,self.nout,natoms,3)) + self.assertEqual(vv.shape, (nframes,self.nout,9)) + self.assertEqual(at.shape, (nframes,nsel,self.nout)) + self.assertEqual(av.shape, (nframes,self.nout,natoms,9)) + # check values + np.testing.assert_almost_equal(ff.reshape([-1]), self.expected_f.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(at.reshape([-1]), self.expected_t.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(av.reshape([-1]), self.expected_v.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(gt.reshape([-1]), self.expected_gt.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(vv.reshape([-1]), self.expected_gv.reshape([-1]), decimal = default_places) + + def test_1frame_full_atm_shuffle(self): + i_sf = [2,1,3,0,5,4] + isel_sf = i_sf + gt, ff, vv, at, av = self.dp.eval_full(self.coords.reshape(-1,3)[i_sf].reshape(-1), self.box, self.atype[i_sf], atomic = True) + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + nsel = natoms + self.assertEqual(gt.shape, (nframes,self.nout)) + self.assertEqual(ff.shape, (nframes,self.nout,natoms,3)) + self.assertEqual(vv.shape, (nframes,self.nout,9)) + self.assertEqual(at.shape, (nframes,nsel,self.nout)) + self.assertEqual(av.shape, (nframes,self.nout,natoms,9)) + # recover the shuffled result + nff = np.empty_like(ff) + nav = np.empty_like(av) + nat = np.empty_like(at) + nff[:, :, i_sf] = ff + nav[:, :, i_sf] = av + nat[:, isel_sf] = at + # check values + np.testing.assert_almost_equal(nff.reshape([-1]), self.expected_f.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(nat.reshape([-1]), self.expected_t.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(nav.reshape([-1]), self.expected_v.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(gt.reshape([-1]), self.expected_gt.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(vv.reshape([-1]), self.expected_gv.reshape([-1]), decimal = default_places) \ No newline at end of file diff --git a/source/tests/test_deeppolar.py b/source/tests/test_deeppolar.py index 0783381548..64dbcbf597 100644 --- a/source/tests/test_deeppolar.py +++ b/source/tests/test_deeppolar.py @@ -4,7 +4,8 @@ from infer.convert2pb import convert_pbtxt_to_pb from deepmd.infer import DeepPolar -from common import tests_path +from common import tests_path, tf +from packaging.version import parse as parse_version from deepmd.env import GLOBAL_NP_FLOAT_PRECISION if GLOBAL_NP_FLOAT_PRECISION == np.float32 : @@ -61,3 +62,201 @@ def test_2frame_atm(self): self.assertAlmostEqual(dd.reshape([-1])[ii], expected_d.reshape([-1])[ii], places = default_places) +class TestDeepPolarNoPBC(unittest.TestCase) : + def setUp(self): + convert_pbtxt_to_pb(str(tests_path / os.path.join("infer","deeppolar.pbtxt")), "deeppolar.pb") + self.dp = DeepPolar("deeppolar.pb") + self.coords = np.array([12.83, 2.56, 2.18, + 12.09, 2.87, 2.74, + 00.25, 3.32, 1.68, + 3.36, 3.00, 1.81, + 3.51, 2.51, 2.60, + 4.27, 3.22, 1.56]) + self.atype = [0, 1, 1, 0, 1, 1] + self.box = np.array([20., 0., 0., 0., 20., 0., 0., 0., 20.]) + self.expected_d = np.array([5.601785462021734e-01, -2.346693909765864e-01, -4.239188998286720e-01, -2.346693909765862e-01, 9.830744757127260e-02, 1.775876472255247e-01, -4.239188998286717e-01, 1.775876472255248e-01, 3.208034917622381e-01, 1.302526099276315e+00, -3.784198124746947e-01, 7.548241853986054e-01, -3.784198124746949e-01, 1.098824690874320e-01, -2.194150345809899e-01, 7.548241853986057e-01, -2.194150345809898e-01, 4.382376148484938e-01]) + + def tearDown(self): + os.remove("deeppolar.pb") + + def test_1frame_atm(self): + dd = self.dp.eval(self.coords, None, self.atype) + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + nsel = 2 + self.assertEqual(dd.shape, (nframes,nsel,9)) + # check values + for ii in range(dd.size): + self.assertAlmostEqual(dd.reshape([-1])[ii], self.expected_d.reshape([-1])[ii], places = default_places) + + def test_1frame_atm_large_box(self): + dd = self.dp.eval(self.coords, self.box, self.atype) + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + nsel = 2 + self.assertEqual(dd.shape, (nframes,nsel,9)) + # check values + for ii in range(dd.size): + self.assertAlmostEqual(dd.reshape([-1])[ii], self.expected_d.reshape([-1])[ii], places = default_places) + + +@unittest.skipIf(parse_version(tf.__version__) < parse_version("1.15"), + f"The current tf version {tf.__version__} is too low to run the new testing model.") +class TestDeepPolarNewPBC(unittest.TestCase) : + def setUp(self): + convert_pbtxt_to_pb(str(tests_path / os.path.join("infer","deeppolar_new.pbtxt")), "deeppolar_new.pb") + self.dp = DeepPolar("deeppolar_new.pb") + self.coords = np.array([12.83, 2.56, 2.18, + 12.09, 2.87, 2.74, + 00.25, 3.32, 1.68, + 3.36, 3.00, 1.81, + 3.51, 2.51, 2.60, + 4.27, 3.22, 1.56]) + self.nout = 9 + self.atype = np.array([0, 1, 1, 0, 1, 1]) + self.box = np.array([13., 0., 0., 0., 13., 0., 0., 0., 13.]) + self.expected_t = np.array([1.936327241487292961e+00, 5.198696351735779264e-02, 3.888336625074450149e-03, 5.198696351735781346e-02, 1.764967784387830196e+00, -1.354658545697527347e-02, 3.888336625074451016e-03, -1.354658545697527000e-02, 1.939288409902199639e+00, 1.786740420980893029e+00, 4.868765294055640847e-02, -9.812132615180739481e-02, 4.868765294055640847e-02, 1.925999147066305373e+00, 2.895028407651457567e-02, -9.812132615180743644e-02, 2.895028407651457220e-02, 1.883109989034779996e+00]) + self.expected_f = np.array([5.305178446980116092e-02, -1.127314829623577049e-02, 1.136493514861047216e-01, 5.598130220328862322e-05, -4.352126938892845326e-02, -7.700608888887500170e-02, -1.050015668789053697e-01, 5.882396336737016895e-02, -3.723875897544067642e-02, -7.850322286760008650e-02, 7.279117637753844405e-02, -6.178451060078461732e-02, 3.404361490778949895e-01, 5.447934529195214842e-02, -8.698375128815737101e-02, -2.100391251033939810e-01, -1.313000673516965255e-01, 1.493637582671529240e-01, -9.589318874236771317e-02, 6.285887854370801608e-02, -1.824395427630142175e-01, -3.264267092869802683e-02, 3.637498661083633789e-02, 1.524859582123189172e-01, 1.442484990808054202e-01, -8.957992476622803069e-02, 3.076469140583825215e-02, 4.909822745881124717e-02, -2.559151672032903835e-01, -1.522830913546814324e-01, -2.885480042033320910e-02, 7.730841025065784966e-02, 1.553301391955271560e-01, -3.595606644821771475e-02, 1.689528165643162105e-01, -3.858154695988691516e-03, 5.018843026262573281e-02, 1.756005154318779349e-02, 3.489323893614350303e-02, -4.020411124876955428e-02, 2.218648284685413238e-02, -8.086177159691650476e-03, -2.222392408702593067e-02, -3.825892777133557687e-02, -1.689393838770965675e-02, -5.465804822761769627e-02, -1.398775875506316768e-01, -1.165702490994514756e-01, 5.449067849718619572e-02, 1.588580450812354106e-01, -8.209560373418453572e-02, 1.240697480360127003e-02, -2.046806414931008622e-02, 1.887527294448937965e-01, -9.589318874236771317e-02, 6.285887854370801608e-02, -1.824395427630142175e-01, -3.264267092869802683e-02, 3.637498661083633789e-02, 1.524859582123189172e-01, 1.442484990808054202e-01, -8.957992476622803069e-02, 3.076469140583825215e-02, 4.909822745881124717e-02, -2.559151672032903835e-01, -1.522830913546814324e-01, -2.885480042033320910e-02, 7.730841025065784966e-02, 1.553301391955271560e-01, -3.595606644821771475e-02, 1.689528165643162105e-01, -3.858154695988691516e-03, 4.038746042068122599e-02, -2.549213597407858356e-01, -1.131801705114504619e-01, 1.489732376295762606e-01, 2.734584831542113958e-01, -1.125511889088352951e-01, -1.908551011160136424e-01, -2.400995606986339528e-02, 2.255650484976146619e-01, -2.185213968874370055e-02, 1.475333123369945709e-01, 9.584417756169674729e-02, -1.576380405016522893e-02, -5.153693137796186430e-02, -8.489897831367294867e-02, 3.911034680466508873e-02, -9.052354830259493057e-02, -1.077888832535272776e-02, -1.970229486427777510e-01, -6.538978166042377915e-02, -1.570533119125729904e-01, 1.417940206277617798e-01, -4.684714285705613573e-02, 6.070882964241105378e-02, 5.715183445260185735e-02, 1.138024049318459713e-01, 9.374622673558237473e-02, 3.096927839536914306e-02, -9.232883741117139942e-02, -6.499836527010099951e-02, 2.839980861544661936e-02, 8.097497759757724123e-03, 1.006700103228213017e-01, -6.129199344840163821e-02, 8.266585923704758421e-02, -3.307338951814068478e-02, 5.018843026262574669e-02, 1.756005154318778308e-02, 3.489323893614350997e-02, -4.020411124876957509e-02, 2.218648284685414279e-02, -8.086177159691652211e-03, -2.222392408702593067e-02, -3.825892777133557687e-02, -1.689393838770965675e-02, -5.465804822761770321e-02, -1.398775875506316491e-01, -1.165702490994514756e-01, 5.449067849718619572e-02, 1.588580450812354106e-01, -8.209560373418453572e-02, 1.240697480360125615e-02, -2.046806414931009316e-02, 1.887527294448937965e-01, -1.970229486427777510e-01, -6.538978166042375140e-02, -1.570533119125729626e-01, 1.417940206277618076e-01, -4.684714285705613573e-02, 6.070882964241105378e-02, 5.715183445260184347e-02, 1.138024049318459713e-01, 9.374622673558236086e-02, 3.096927839536912919e-02, -9.232883741117139942e-02, -6.499836527010102727e-02, 2.839980861544661589e-02, 8.097497759757731062e-03, 1.006700103228213017e-01, -6.129199344840162433e-02, 8.266585923704758421e-02, -3.307338951814066397e-02, -3.078161564779093723e-02, -8.748776750553553111e-03, -2.162930108693108394e-02, 2.135313622214399243e-02, -8.845621737097757523e-03, 9.365293934359546560e-03, 8.562579091543631032e-03, 1.772751551871581607e-02, 1.573655414890783033e-02, -3.649820158632081230e-02, -1.904914900326310223e-01, -1.076542087674599024e-01, -5.186655049718805199e-02, 1.686765146765009937e-01, -6.620206332305828001e-02, 8.923065241761217459e-02, 2.168185832506550753e-02, 1.703837250941818704e-01]) + self.expected_v = np.array([-2.123013313652813774e-03, -2.646248889538913257e-04, 2.225254748021367093e-04, 9.843593195853941446e-04, 1.226963457840150472e-04, -1.031764725911038809e-04, -8.467513732241481721e-04, -1.055440805151912256e-04, 8.875297679686559459e-05, 1.829118379697145316e-02, 2.302438731350108913e-03, -1.890198823577125386e-03, 3.300229266409118040e-02, -1.339230641165423293e-02, -2.445540228188634868e-02, 5.127826101331301595e-02, -2.458314752619149279e-02, -4.252530480245884925e-02, 9.733043787604266084e-02, -6.217238566516904152e-02, 3.767656091618994812e-02, 6.674680725588777973e-03, 4.245867422406505304e-02, -2.752200660186601699e-02, -8.318636634138946995e-03, -2.738884420387305285e-02, 1.785195524121836741e-02, -3.151218435289559073e-03, -3.927864338604547816e-04, 3.302976830190196104e-04, 1.387198082848713948e-06, 1.729085429046553641e-07, -1.454003656243721975e-07, -4.056191292896940703e-05, -5.055875832506090064e-06, 4.251531950061960394e-06, 7.087482338961141604e-02, -1.643445525800983908e-01, 2.668682182870234509e-01, 7.752581706917366366e-03, -2.674714571946596939e-02, 4.308263417785011123e-02, -9.385640612496094423e-03, 4.307848167667025635e-02, -6.910099104451945806e-02, -1.822493611414978121e-01, -4.510097387143227610e-02, 5.157836206906134952e-02, -1.170389534066011428e-01, -2.858136680923874240e-02, 3.256883555835647648e-02, 1.336331160725280354e-01, 3.257484898923947853e-02, -3.710113093740719653e-02, 3.343993600586595179e-03, 4.168150663620683060e-04, -3.505035785317401481e-04, -4.312491363797464269e-03, -5.375343342977005178e-04, 4.520175083867039156e-04, -5.045304632809267465e-04, -6.288764981405317546e-05, 5.288279643454484632e-05, 2.176577726533836937e-02, -1.041710664445027849e-02, -1.802940684978692962e-02, -3.097121964369356495e-02, 1.077096511204005125e-02, 2.079488766754130843e-02, -1.120464690158002596e-01, 4.736950869652114399e-02, 8.530900293808066359e-02, 3.029112757823893692e-02, 1.058529311156591879e-01, -6.894903720238335088e-02, -5.089618157121258979e-02, -6.973511953466600410e-02, 4.618114280030299196e-02, 1.143309394598741001e-02, 2.319568285212985151e-02, -1.522637168466081138e-02, -1.535733649675188493e-03, -1.914228911776438445e-04, 1.609692493993826663e-04, -2.603290366421702733e-03, -3.244894507721100851e-04, 2.728661290583660171e-04, 6.938458118266074663e-04, 8.648503036932213837e-05, -7.272604826511198082e-05, -2.609239945314979423e-02, 1.142603664459106681e-02, -2.051406106454568487e-02, 5.779549344910496142e-03, -3.860615030463052100e-02, 6.168332781226748551e-02, 2.068839156841529789e-02, -7.643723474881176927e-02, 1.229844977392647865e-01, -3.554667688747349674e-02, -8.262665730398828859e-03, 9.285295046969522723e-03, 1.497274901467501862e-01, 3.666859638982037511e-02, -4.181688913175674732e-02, -3.257377626487627069e-03, -8.171909213273372040e-04, 9.379633299917983094e-04, 5.408910405506226968e-04, 6.741984641424190365e-05, -5.669396175743082354e-05, 4.696290607396237790e-04, 5.853733334998140626e-05, -4.922457577157541143e-05, -5.350269144276139158e-03, -6.668890718077903363e-04, 5.607930831110977251e-04, 3.013271000130106694e-02, -1.241570117891089425e-02, -2.255430712666738058e-02, -1.643158253499693577e-02, 6.876116339617440766e-03, 1.242585434168311936e-02, 2.120265775977717496e-03, -2.988284987993197143e-03, -4.123302560925387432e-03, 3.528008965720315360e-02, -1.132921329184741026e-02, 6.435692645130823564e-03, -2.115291124444698342e-02, -2.971050496327276927e-02, 1.966236467455729359e-02, -2.194244461519655187e-02, -1.469000955331024871e-02, 1.000316933044766328e-02, -2.208576023807404254e-03, -2.752899293131040766e-04, 2.314938041951108548e-04, -5.840262773118632192e-04, -7.279647649213021596e-05, 6.121521886838239123e-05, -1.263538670848133802e-03, -1.574949051482092536e-04, 1.324388975109944740e-04, 8.955566031735841259e-03, -2.660296383100100095e-02, 4.296567375352825652e-02, 2.380373596470350059e-02, -7.784355459714024927e-02, 1.255004729498893912e-01, -1.824501349606120690e-02, 3.948761180940744964e-02, -6.423389834199008663e-02, 1.038606825469970407e-02, 2.616819816765628484e-03, -3.006960935423359793e-03, -1.864007491704058883e-02, -4.504736174636920880e-03, 5.118497771104377897e-03, 1.680266347982039554e-01, 4.105963063126880086e-02, -4.679634408112137711e-02, 3.343993600586595179e-03, 4.168150663620683060e-04, -3.505035785317401481e-04, -4.312491363797464269e-03, -5.375343342977005178e-04, 4.520175083867039156e-04, -5.045304632809267465e-04, -6.288764981405317546e-05, 5.288279643454484632e-05, 2.176577726533836937e-02, -1.041710664445027849e-02, -1.802940684978692962e-02, -3.097121964369356495e-02, 1.077096511204005125e-02, 2.079488766754130843e-02, -1.120464690158002596e-01, 4.736950869652114399e-02, 8.530900293808066359e-02, 3.029112757823893692e-02, 1.058529311156591879e-01, -6.894903720238335088e-02, -5.089618157121258979e-02, -6.973511953466600410e-02, 4.618114280030299196e-02, 1.143309394598741001e-02, 2.319568285212985151e-02, -1.522637168466081138e-02, -1.535733649675188493e-03, -1.914228911776438445e-04, 1.609692493993826663e-04, -2.603290366421702733e-03, -3.244894507721100851e-04, 2.728661290583660171e-04, 6.938458118266074663e-04, 8.648503036932213837e-05, -7.272604826511198082e-05, -2.609239945314979423e-02, 1.142603664459106681e-02, -2.051406106454568487e-02, 5.779549344910496142e-03, -3.860615030463052100e-02, 6.168332781226748551e-02, 2.068839156841529789e-02, -7.643723474881176927e-02, 1.229844977392647865e-01, -3.554667688747349674e-02, -8.262665730398828859e-03, 9.285295046969522723e-03, 1.497274901467501862e-01, 3.666859638982037511e-02, -4.181688913175674732e-02, -3.257377626487627069e-03, -8.171909213273372040e-04, 9.379633299917983094e-04, 1.097257666720985849e-03, 1.367686610077148478e-04, -1.150100103928514269e-04, -3.252401295559594844e-03, -4.053984617694676175e-04, 3.409032519425078027e-04, -1.217154259382106555e-04, -1.517132787898375553e-05, 1.275770753460001047e-05, -1.104423096905816498e-01, 4.615651100464009809e-02, 8.344619780982527601e-02, -1.998235369855275168e-01, 8.508819942125579738e-02, 1.528709647298205909e-01, 8.333302476347614896e-02, -3.488524142655123617e-02, -6.303339769808283255e-02, -7.468341447282240975e-02, -1.443673498458480642e-01, 9.485360739696327426e-02, -2.685004652445167612e-04, -1.702408228533323561e-02, 1.097613894113106531e-02, 9.496752299747332482e-02, 1.714581306702349373e-01, -1.128066531362114239e-01, -2.109671824413435984e-03, -2.629619271223545066e-04, 2.211270750801623281e-04, 1.011694656468142307e-02, 1.261035832424879221e-03, -1.060416495448196581e-03, 2.326027531269699879e-04, 2.899297772687444119e-05, -2.438045854305356789e-05, -9.775618976121780001e-04, 7.897148922927013995e-03, -1.259878571596698138e-02, -5.534571406250721713e-03, 2.552681480358522451e-02, -4.094434810336724379e-02, -1.258721457759937913e-02, 4.161890111720080443e-02, -6.708566706120022705e-02, 3.521744971093632853e-02, 8.557787631933998912e-03, -9.738493960065902622e-03, -8.446926488038911107e-02, -2.017604402799078392e-02, 2.285024948138817888e-02, -9.755577915095828626e-03, -2.364722966186930900e-03, 2.689144780896026744e-03, 8.392348196279006065e-05, 1.046071729847805219e-05, -8.796512273720217211e-06, -2.967282659264359589e-03, -3.698595949224694123e-04, 3.110182957302592738e-04, -1.688223115474902841e-03, -2.104300767164184042e-04, 1.769525645115341121e-04, -1.040849854787611189e-01, 4.406117175034113265e-02, 7.931633477513304331e-02, 3.539829580561168476e-02, -1.443144702217136026e-02, -2.631106338063535569e-02, -4.383990895980735547e-02, 1.895493123709470276e-02, 3.388325869579450478e-02, 1.809448338386955915e-02, 4.269882582195522885e-02, -2.795653019460052346e-02, 4.363124777259473619e-02, 8.597058258914810902e-02, -5.646456449126337207e-02, 4.431189331687027805e-02, 7.186269332716928304e-02, -4.739074421553418626e-02, 7.807665162715203382e-05, 9.731933913865978996e-06, -8.183671700296416994e-06, 2.525821455836478949e-03, 3.148332692827336839e-04, -2.647461582604813284e-04, 5.088778918832323993e-03, 6.342953893162101269e-04, -5.333847591977234877e-04, 1.765533347871811772e-03, -1.422682766506909793e-02, 2.269730547460076936e-02, 2.888222424864686153e-04, -4.083171371247279469e-03, 6.494062010930001794e-03, 1.594130471018519873e-02, -4.922350239779287734e-02, 7.944117864515577720e-02, -5.516443865142822006e-02, -1.340804559261108905e-02, 1.525892700429632917e-02, 7.450140187529649682e-02, 1.809617933997387934e-02, -2.059052256811338619e-02, -3.118940445306414219e-02, -7.412336287839308216e-03, 8.382871287998559101e-03, 5.408910405506207452e-04, 6.741984641424155129e-05, -5.669396175743063380e-05, 4.696290607396231285e-04, 5.853733334998132494e-05, -4.922457577157534367e-05, -5.350269144276134821e-03, -6.668890718077897942e-04, 5.607930831110975083e-04, 3.013271000130106694e-02, -1.241570117891090119e-02, -2.255430712666738752e-02, -1.643158253499694271e-02, 6.876116339617444236e-03, 1.242585434168312457e-02, 2.120265775977718363e-03, -2.988284987993198010e-03, -4.123302560925387432e-03, 3.528008965720314666e-02, -1.132921329184741026e-02, 6.435692645130823564e-03, -2.115291124444698342e-02, -2.971050496327276927e-02, 1.966236467455729012e-02, -2.194244461519655881e-02, -1.469000955331024871e-02, 1.000316933044766501e-02, -2.208576023807403820e-03, -2.752899293131040766e-04, 2.314938041951108548e-04, -5.840262773118632192e-04, -7.279647649213021596e-05, 6.121521886838239123e-05, -1.263538670848133802e-03, -1.574949051482092536e-04, 1.324388975109944740e-04, 8.955566031735841259e-03, -2.660296383100100095e-02, 4.296567375352825652e-02, 2.380373596470350059e-02, -7.784355459714024927e-02, 1.255004729498893912e-01, -1.824501349606121037e-02, 3.948761180940744964e-02, -6.423389834199008663e-02, 1.038606825469969019e-02, 2.616819816765625015e-03, -3.006960935423356324e-03, -1.864007491704059577e-02, -4.504736174636922615e-03, 5.118497771104379632e-03, 1.680266347982039554e-01, 4.105963063126880086e-02, -4.679634408112137711e-02, 8.392348196278930170e-05, 1.046071729847797087e-05, -8.796512273720142672e-06, -2.967282659264356987e-03, -3.698595949224691413e-04, 3.110182957302590027e-04, -1.688223115474903708e-03, -2.104300767164184855e-04, 1.769525645115341934e-04, -1.040849854787611189e-01, 4.406117175034113265e-02, 7.931633477513304331e-02, 3.539829580561167782e-02, -1.443144702217136026e-02, -2.631106338063535569e-02, -4.383990895980735547e-02, 1.895493123709470276e-02, 3.388325869579450478e-02, 1.809448338386955221e-02, 4.269882582195521498e-02, -2.795653019460051653e-02, 4.363124777259472925e-02, 8.597058258914809514e-02, -5.646456449126335819e-02, 4.431189331687027111e-02, 7.186269332716926916e-02, -4.739074421553417932e-02, 7.807665162715246750e-05, 9.731933913866019654e-06, -8.183671700296457651e-06, 2.525821455836478515e-03, 3.148332692827336297e-04, -2.647461582604812742e-04, 5.088778918832324860e-03, 6.342953893162102353e-04, -5.333847591977235961e-04, 1.765533347871809603e-03, -1.422682766506909793e-02, 2.269730547460076589e-02, 2.888222424864694826e-04, -4.083171371247282938e-03, 6.494062010930008733e-03, 1.594130471018519873e-02, -4.922350239779287040e-02, 7.944117864515577720e-02, -5.516443865142821312e-02, -1.340804559261108558e-02, 1.525892700429632570e-02, 7.450140187529649682e-02, 1.809617933997387934e-02, -2.059052256811338966e-02, -3.118940445306412831e-02, -7.412336287839304746e-03, 8.382871287998553897e-03, -9.575909105642434974e-04, -1.193597735547498307e-04, 1.003707186710399045e-04, -9.520061199010912585e-05, -1.186636523389461756e-05, 9.978534401229592523e-06, -5.876800709203859434e-03, -7.325190685693192200e-04, 6.159819440242017292e-04, -1.659431774532551043e-02, 6.520628417529478540e-03, 1.204087494393247214e-02, 6.518824051016284399e-03, -2.745500204548994606e-03, -4.950724849051978994e-03, -5.340810191179472081e-03, 3.101366677982481286e-03, 5.077959020099345744e-03, 7.727976016970144156e-03, 7.022558645366243878e-03, -4.714356496325102820e-03, 7.018017321145150929e-03, 1.341962078953426278e-02, -8.818944869050635710e-03, -2.755773236988961865e-03, 1.079245666846929096e-02, -6.886663303228377636e-03, 9.801230913130992879e-04, 1.221683173308112048e-04, -1.027324486645460452e-04, 1.233918620327190629e-04, 1.538028875195364422e-05, -1.293342463232469071e-05, 4.892751025155074075e-03, 6.098613175830685205e-04, -5.128379261493998297e-04, -7.792305682365031905e-03, 2.541307371885552502e-02, -4.097328323558844382e-02, 2.530143617608526449e-02, -8.265149730513186854e-02, 1.332544508945474881e-01, -1.184335640259520997e-02, 3.220055758982264676e-02, -5.209911236104310117e-02, 8.090761694886683397e-02, 1.959431243541279177e-02, -2.227702786419644143e-02, 1.968691296265078980e-02, 4.764576998712748319e-03, -5.415896903683155988e-03, 1.534638141861073557e-01, 3.728680895816388619e-02, -4.242975875503233324e-02]) + self.expected_gt = self.expected_t.reshape(-1, self.nout).sum(0).reshape(-1) + self.expected_gv = self.expected_v.reshape(1, self.nout, 6, 9).sum(-2).reshape(-1) + + def tearDown(self): + os.remove("deeppolar_new.pb") + + def test_attrs(self): + self.assertEqual(self.dp.get_ntypes(), 2) + self.assertAlmostEqual(self.dp.get_rcut(), 6.0, places = default_places) + self.assertEqual(self.dp.get_type_map(), ['O', 'H']) + self.assertEqual(self.dp.get_sel_type(), [0]) + + def test_1frame_old(self): + gt = self.dp.eval(self.coords, self.box, self.atype, atomic=False) + # check shape of the returns + nframes = 1 + self.assertEqual(gt.shape, (nframes,self.nout)) + # check values + for ii in range(gt.size): + self.assertAlmostEqual(gt.reshape([-1])[ii], self.expected_gt.reshape([-1])[ii], places = default_places) + + def test_1frame_old_atm(self): + at = self.dp.eval(self.coords, self.box, self.atype) + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + nsel = 2 + self.assertEqual(at.shape, (nframes,nsel,self.nout)) + # check values + for ii in range(at.size): + self.assertAlmostEqual(at.reshape([-1])[ii], self.expected_t.reshape([-1])[ii], places = default_places) + + def test_2frame_old_atm(self): + coords2 = np.concatenate((self.coords, self.coords)) + box2 = np.concatenate((self.box, self.box)) + at = self.dp.eval(coords2, box2, self.atype) + # check shape of the returns + nframes = 2 + natoms = len(self.atype) + nsel = 2 + self.assertEqual(at.shape, (nframes,nsel,self.nout)) + # check values + expected_d = np.concatenate((self.expected_t, self.expected_t)) + for ii in range(at.size): + self.assertAlmostEqual(at.reshape([-1])[ii], expected_d.reshape([-1])[ii], places = default_places) + + def test_1frame_full(self): + gt, ff, vv = self.dp.eval_full(self.coords, self.box, self.atype, atomic = False) + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + self.assertEqual(gt.shape, (nframes,self.nout)) + self.assertEqual(ff.shape, (nframes,self.nout,natoms,3)) + self.assertEqual(vv.shape, (nframes,self.nout,9)) + # check values + for ii in range(ff.size): + self.assertAlmostEqual(ff.reshape([-1])[ii], self.expected_f.reshape([-1])[ii], places = default_places) + for ii in range(gt.size): + self.assertAlmostEqual(gt.reshape([-1])[ii], self.expected_gt.reshape([-1])[ii], places = default_places) + for ii in range(vv.size): + self.assertAlmostEqual(vv.reshape([-1])[ii], self.expected_gv.reshape([-1])[ii], places = default_places) + + def test_1frame_full_atm(self): + gt, ff, vv, at, av = self.dp.eval_full(self.coords, self.box, self.atype, atomic = True) + + # print the values + for dd in (at, ff, av): + print("\n\n") + print(", ".join(f"{i:.18e}" for i in dd.reshape(-1))) + print("\n\n") + + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + nsel = 2 + self.assertEqual(gt.shape, (nframes,self.nout)) + self.assertEqual(ff.shape, (nframes,self.nout,natoms,3)) + self.assertEqual(vv.shape, (nframes,self.nout,9)) + self.assertEqual(at.shape, (nframes,nsel,self.nout)) + self.assertEqual(av.shape, (nframes,self.nout,natoms,9)) + # check values + np.testing.assert_almost_equal(ff.reshape([-1]), self.expected_f.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(at.reshape([-1]), self.expected_t.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(av.reshape([-1]), self.expected_v.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(gt.reshape([-1]), self.expected_gt.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(vv.reshape([-1]), self.expected_gv.reshape([-1]), decimal = default_places) + + def test_1frame_full_atm_shuffle(self): + i_sf = [2,1,3,0,5,4] + isel_sf = [1,0] + gt, ff, vv, at, av = self.dp.eval_full(self.coords.reshape(-1,3)[i_sf].reshape(-1), self.box, self.atype[i_sf], atomic = True) + # check shape of the returns + nframes = 1 + natoms = len(self.atype) + nsel = 2 + self.assertEqual(gt.shape, (nframes,self.nout)) + self.assertEqual(ff.shape, (nframes,self.nout,natoms,3)) + self.assertEqual(vv.shape, (nframes,self.nout,9)) + self.assertEqual(at.shape, (nframes,nsel,self.nout)) + self.assertEqual(av.shape, (nframes,self.nout,natoms,9)) + # recover the shuffled result + nff = np.empty_like(ff) + nav = np.empty_like(av) + nat = np.empty_like(at) + nff[:, :, i_sf] = ff + nav[:, :, i_sf] = av + nat[:, isel_sf] = at + # check values + np.testing.assert_almost_equal(nff.reshape([-1]), self.expected_f.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(nat.reshape([-1]), self.expected_t.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(nav.reshape([-1]), self.expected_v.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(gt.reshape([-1]), self.expected_gt.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(vv.reshape([-1]), self.expected_gv.reshape([-1]), decimal = default_places) + + + def test_2frame_full_atm(self): + coords2 = np.concatenate((self.coords, self.coords)) + box2 = np.concatenate((self.box, self.box)) + gt, ff, vv, at, av = self.dp.eval_full(coords2, box2, self.atype, atomic = True) + # check shape of the returns + nframes = 2 + natoms = len(self.atype) + nsel = 2 + self.assertEqual(gt.shape, (nframes,self.nout)) + self.assertEqual(ff.shape, (nframes,self.nout,natoms,3)) + self.assertEqual(vv.shape, (nframes,self.nout,9)) + self.assertEqual(at.shape, (nframes,nsel,self.nout)) + self.assertEqual(av.shape, (nframes,self.nout,natoms,9)) + # check values + expected_f = np.tile(self.expected_f.reshape(-1), nframes) + expected_t = np.tile(self.expected_t.reshape(-1), nframes) + expected_v = np.tile(self.expected_v.reshape(-1), nframes) + expected_gt = np.tile(self.expected_gt.reshape(-1), nframes) + expected_gv = np.tile(self.expected_gv.reshape(-1), nframes) + np.testing.assert_almost_equal(ff.reshape([-1]), expected_f.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(at.reshape([-1]), expected_t.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(av.reshape([-1]), expected_v.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(gt.reshape([-1]), expected_gt.reshape([-1]), decimal = default_places) + np.testing.assert_almost_equal(vv.reshape([-1]), expected_gv.reshape([-1]), decimal = default_places) + diff --git a/source/tests/test_dipole_se_a.py b/source/tests/test_dipole_se_a.py index eb4396dec1..26a86c137b 100644 --- a/source/tests/test_dipole_se_a.py +++ b/source/tests/test_dipole_se_a.py @@ -2,6 +2,7 @@ import numpy as np from deepmd.env import tf from common import Data,gen_data, j_loader +from common import finite_difference, strerch_box from deepmd.utils.data_system import DataSystem from deepmd.descriptor import DescrptSeA @@ -76,6 +77,10 @@ def test_model(self): suffix = "dipole_se_a", reuse = False) dipole = model_pred['dipole'] + gdipole = model_pred['global_dipole'] + force = model_pred['force'] + virial = model_pred['virial'] + atom_virial = model_pred['atom_virial'] feed_dict_test = {t_prop_c: test_data['prop_c'], t_coord: np.reshape(test_data['coord'] [:numb_test, :], [-1]), @@ -87,7 +92,7 @@ def test_model(self): sess = tf.Session() sess.run(tf.global_variables_initializer()) - [p] = sess.run([dipole], feed_dict = feed_dict_test) + [p, gp] = sess.run([dipole, gdipole], feed_dict = feed_dict_test) p = p.reshape([-1]) refp = [1.616802262298876514e+01,9.809535439521079425e+00,3.572312180768947854e-01,1.336308874095981203e+00,1.057908563208963848e+01,-5.999602350098874881e-01] @@ -96,5 +101,50 @@ def test_model(self): for ii in range(p.size) : self.assertAlmostEqual(p[ii], refp[ii], places = places) + gp = gp.reshape([-1]) + refgp = np.array(refp).reshape(-1, 3).sum(0) - + places = 9 + for ii in range(gp.size) : + self.assertAlmostEqual(gp[ii], refgp[ii], places = places) + + # make sure only one frame is used + feed_dict_single = {t_prop_c: test_data['prop_c'], + t_coord: np.reshape(test_data['coord'] [:1, :], [-1]), + t_box: test_data['box'] [:1, :], + t_type: np.reshape(test_data['type'] [:1, :], [-1]), + t_natoms: test_data['natoms_vec'], + t_mesh: test_data['default_mesh'], + is_training: False} + + [pf, pv, pav] = sess.run([force, virial, atom_virial], feed_dict = feed_dict_single) + pf, pv = pf.reshape(-1), pv.reshape(-1) + spv = pav.reshape(1, 3, -1, 9).sum(2).reshape(-1) + + base_dict = feed_dict_single.copy() + coord0 = base_dict.pop(t_coord) + box0 = base_dict.pop(t_box) + + fdf = - finite_difference( + lambda coord: sess.run(gdipole, + feed_dict={**base_dict, + t_coord:coord, + t_box:box0}).reshape(-1), + test_data['coord'][:numb_test, :].reshape([-1])).reshape(-1) + fdv = - (finite_difference( + lambda box: sess.run(gdipole, + feed_dict={**base_dict, + t_coord:strerch_box(coord0, box0, box), + t_box:box}).reshape(-1), + test_data['box'][:numb_test, :]).reshape([-1,3,3]).transpose(0,2,1) + @ box0.reshape(3,3)).reshape(-1) + + delta = 1e-5 + for ii in range(pf.size) : + self.assertAlmostEqual(pf[ii], fdf[ii], delta = delta) + for ii in range(pv.size) : + self.assertAlmostEqual(pv[ii], fdv[ii], delta = delta) + # make sure atomic virial sum to virial + places = 10 + for ii in range(pv.size) : + self.assertAlmostEqual(pv[ii], spv[ii], places = places) \ No newline at end of file diff --git a/source/tests/test_polar_se_a.py b/source/tests/test_polar_se_a.py index 4049aee717..c84bc0aa6d 100644 --- a/source/tests/test_polar_se_a.py +++ b/source/tests/test_polar_se_a.py @@ -2,6 +2,7 @@ import numpy as np from deepmd.env import tf from common import Data,gen_data, j_loader +from common import finite_difference, strerch_box from deepmd.utils.data_system import DataSystem from deepmd.descriptor import DescrptSeA @@ -75,6 +76,10 @@ def test_model(self): suffix = "polar_se_a", reuse = False) polar = model_pred['polar'] + gpolar = model_pred['global_polar'] + force = model_pred['force'] + virial = model_pred['virial'] + atom_virial = model_pred['atom_virial'] feed_dict_test = {t_prop_c: test_data['prop_c'], t_coord: np.reshape(test_data['coord'] [:numb_test, :], [-1]), @@ -86,7 +91,7 @@ def test_model(self): sess = tf.Session() sess.run(tf.global_variables_initializer()) - [p] = sess.run([polar], feed_dict = feed_dict_test) + [p, gp] = sess.run([polar, gpolar], feed_dict = feed_dict_test) p = p.reshape([-1]) refp = [3.39695248e+01, 2.16564043e+01, 8.18501479e-01, 2.16564043e+01, 1.38211789e+01, 5.22775159e-01, 8.18501479e-01, 5.22775159e-01, 1.97847218e-02, 8.08467431e-01, 3.42081126e+00, -2.01072261e-01, 3.42081126e+00, 1.54924596e+01, -9.06153697e-01, -2.01072261e-01, -9.06153697e-01, 5.30193262e-02] @@ -95,5 +100,50 @@ def test_model(self): for ii in range(p.size) : self.assertAlmostEqual(p[ii], refp[ii], places = places) - + gp = gp.reshape([-1]) + refgp = np.array(refp).reshape(-1, 9).sum(0) + places = 5 + for ii in range(gp.size) : + self.assertAlmostEqual(gp[ii], refgp[ii], places = places) + + # make sure only one frame is used + feed_dict_single = {t_prop_c: test_data['prop_c'], + t_coord: np.reshape(test_data['coord'] [:1, :], [-1]), + t_box: test_data['box'] [:1, :], + t_type: np.reshape(test_data['type'] [:1, :], [-1]), + t_natoms: test_data['natoms_vec'], + t_mesh: test_data['default_mesh'], + is_training: False} + + [pf, pv, pav] = sess.run([force, virial, atom_virial], feed_dict = feed_dict_single) + pf, pv = pf.reshape(-1), pv.reshape(-1) + spv = pav.reshape(1, 9, -1, 9).sum(2).reshape(-1) + + base_dict = feed_dict_single.copy() + coord0 = base_dict.pop(t_coord) + box0 = base_dict.pop(t_box) + + fdf = - finite_difference( + lambda coord: sess.run(gpolar, + feed_dict={**base_dict, + t_coord:coord, + t_box:box0}).reshape(-1), + test_data['coord'][:numb_test, :].reshape([-1])).reshape(-1) + fdv = - (finite_difference( + lambda box: sess.run(gpolar, + feed_dict={**base_dict, + t_coord:strerch_box(coord0, box0, box), + t_box:box}).reshape(-1), + test_data['box'][:numb_test, :]).reshape([-1,3,3]).transpose(0,2,1) + @ box0.reshape(3,3)).reshape(-1) + + delta = 1e-4 + for ii in range(pf.size) : + self.assertAlmostEqual(pf[ii], fdf[ii], delta = delta) + for ii in range(pv.size) : + self.assertAlmostEqual(pv[ii], fdv[ii], delta = delta) + # make sure atomic virial sum to virial + places = 10 + for ii in range(pv.size) : + self.assertAlmostEqual(pv[ii], spv[ii], places = places)