From dd163a52f632fa6fa3fa97cd965692145789a6cb Mon Sep 17 00:00:00 2001 From: namish800 Date: Thu, 1 Nov 2018 14:49:10 +0530 Subject: [PATCH 01/12] *Removed package.json and package-lock.json *Added info for supported frameworks. *Added Length layer *Added MaskCapsule layer *Added Capsule layer *Added model to the modelZoo.js --- README.md | 1 + example/keras/Capsnet.json | 414 +++++++++++++++++++++++ ide/static/js/data.js | 120 +++++++ ide/static/js/modelZoo.js | 5 +- ide/static/js/pane.js | 12 + keras_app/custom_layers/capsule_layer.py | 60 ++++ keras_app/custom_layers/config.py | 16 + keras_app/custom_layers/length.py | 20 ++ keras_app/custom_layers/mask_capsule.py | 29 ++ keras_app/custom_layers/squash.py | 24 ++ keras_app/views/export_json.py | 8 +- keras_app/views/import_json.py | 16 +- keras_app/views/layers_export.py | 33 ++ keras_app/views/layers_import.py | 25 ++ 14 files changed, 777 insertions(+), 6 deletions(-) create mode 100644 example/keras/Capsnet.json create mode 100644 keras_app/custom_layers/capsule_layer.py create mode 100644 keras_app/custom_layers/length.py create mode 100644 keras_app/custom_layers/mask_capsule.py create mode 100644 keras_app/custom_layers/squash.py diff --git a/README.md b/README.md index 50db680a2..8fc20e8b5 100644 --- a/README.md +++ b/README.md @@ -291,6 +291,7 @@ Models | Ca [Pix2Pix](https://github.com/phillipi/pix2pix) | √ | × | × | [VQA](https://github.com/iamaaditya/VQA_Demo) | √ | √ | √ | [Denoising Auto-Encoder](https://blog.keras.io/building-autoencoders-in-keras.html) | × | √ | √ | +[CapsNet](https://arxiv.org/abs/1710.09829) | × | √ | √ | Note: For models that use a custom LRN layer (Alexnet), Keras expects the custom layer to be passed when it is loaded from json. LRN.py is located in keras_app/custom_layers. [Alexnet import for Keras](https://github.com/Cloud-CV/Fabrik/blob/master/tutorials/keras_custom_layer_usage.md) diff --git a/example/keras/Capsnet.json b/example/keras/Capsnet.json new file mode 100644 index 000000000..d9ceda43f --- /dev/null +++ b/example/keras/Capsnet.json @@ -0,0 +1,414 @@ +{ + "class_name": "Model", + "keras_version": "2.0.8", + "config": { + "layers": [ + { + "class_name": "InputLayer", + "config": { + "dtype": "float32", + "batch_input_shape": [ + null, + 28, + 28, + 1 + ], + "name": "Input", + "sparse": false + }, + "inbound_nodes": [], + "name": "Input" + }, + { + "class_name": "Conv2D", + "config": { + "kernel_constraint": null, + "kernel_initializer": { + "class_name": "VarianceScaling", + "config": { + "distribution": "uniform", + "scale": 1.0, + "seed": null, + "mode": "fan_avg" + } + }, + "name": "conv1", + "bias_regularizer": null, + "bias_constraint": null, + "activation": "relu", + "trainable": true, + "data_format": "channels_last", + "padding": "valid", + "strides": [ + 1, + 1 + ], + "dilation_rate": [ + 1, + 1 + ], + "kernel_regularizer": null, + "filters": 256, + "bias_initializer": { + "class_name": "Zeros", + "config": {} + }, + "use_bias": true, + "activity_regularizer": null, + "kernel_size": [ + 9, + 9 + ] + }, + "inbound_nodes": [ + [ + [ + "Input", + 0, + 0, + {} + ] + ] + ], + "name": "conv1" + }, + { + "class_name": "Conv2D", + "config": { + "kernel_constraint": null, + "kernel_initializer": { + "class_name": "VarianceScaling", + "config": { + "distribution": "uniform", + "scale": 1.0, + "seed": null, + "mode": "fan_avg" + } + }, + "name": "primarycap_conv2d", + "bias_regularizer": null, + "bias_constraint": null, + "activation": "linear", + "trainable": true, + "data_format": "channels_last", + "padding": "valid", + "strides": [ + 2, + 2 + ], + "dilation_rate": [ + 1, + 1 + ], + "kernel_regularizer": null, + "filters": 256, + "bias_initializer": { + "class_name": "Zeros", + "config": {} + }, + "use_bias": true, + "activity_regularizer": null, + "kernel_size": [ + 9, + 9 + ] + }, + "inbound_nodes": [ + [ + [ + "conv1", + 0, + 0, + {} + ] + ] + ], + "name": "primarycap_conv2d" + }, + { + "class_name": "Reshape", + "config": { + "target_shape": [ + 1152, + 8 + ], + "trainable": true, + "name": "primarycap_reshape" + }, + "inbound_nodes": [ + [ + [ + "primarycap_conv2d", + 0, + 0, + {} + ] + ] + ], + "name": "primarycap_reshape" + }, + { + "class_name": "Squash", + "config": { + "trainable": true, + "name": "primarycap_sqash", + "axis": -1 + }, + "inbound_nodes": [ + [ + [ + "primarycap_reshape", + 0, + 0, + {} + ] + ] + ], + "name": "primarycap_sqash" + }, + { + "class_name": "CapsuleLayer", + "config": { + "num_routing": 3, + "dim_capsule": 16, + "trainable": true, + "name": "digitcaps", + "num_capsule": 10 + }, + "inbound_nodes": [ + [ + [ + "primarycap_sqash", + 0, + 0, + {} + ] + ] + ], + "name": "digitcaps" + }, + { + "class_name": "InputLayer", + "config": { + "dtype": "float32", + "batch_input_shape": [ + null, + 10 + ], + "name": "input_1", + "sparse": false + }, + "inbound_nodes": [], + "name": "input_1" + }, + { + "class_name": "MaskCapsule", + "config": { + "trainable": true, + "name": "mask_capsule_1" + }, + "inbound_nodes": [ + [ + [ + "digitcaps", + 0, + 0, + {} + ], + [ + "input_1", + 0, + 0, + {} + ] + ] + ], + "name": "mask_capsule_1" + }, + { + "class_name": "Dense", + "config": { + "kernel_initializer": { + "class_name": "VarianceScaling", + "config": { + "distribution": "uniform", + "scale": 1.0, + "seed": null, + "mode": "fan_avg" + } + }, + "name": "dense_1", + "kernel_constraint": null, + "bias_regularizer": null, + "bias_constraint": null, + "activation": "relu", + "trainable": true, + "kernel_regularizer": null, + "bias_initializer": { + "class_name": "Zeros", + "config": {} + }, + "units": 512, + "use_bias": true, + "activity_regularizer": null + }, + "inbound_nodes": [ + [ + [ + "mask_capsule_1", + 0, + 0, + {} + ] + ] + ], + "name": "dense_1" + }, + { + "class_name": "Dense", + "config": { + "kernel_initializer": { + "class_name": "VarianceScaling", + "config": { + "distribution": "uniform", + "scale": 1.0, + "seed": null, + "mode": "fan_avg" + } + }, + "name": "dense_2", + "kernel_constraint": null, + "bias_regularizer": null, + "bias_constraint": null, + "activation": "relu", + "trainable": true, + "kernel_regularizer": null, + "bias_initializer": { + "class_name": "Zeros", + "config": {} + }, + "units": 1024, + "use_bias": true, + "activity_regularizer": null + }, + "inbound_nodes": [ + [ + [ + "dense_1", + 0, + 0, + {} + ] + ] + ], + "name": "dense_2" + }, + { + "class_name": "Dense", + "config": { + "kernel_initializer": { + "class_name": "VarianceScaling", + "config": { + "distribution": "uniform", + "scale": 1.0, + "seed": null, + "mode": "fan_avg" + } + }, + "name": "dense_3", + "kernel_constraint": null, + "bias_regularizer": null, + "bias_constraint": null, + "activation": "sigmoid", + "trainable": true, + "kernel_regularizer": null, + "bias_initializer": { + "class_name": "Zeros", + "config": {} + }, + "units": 784, + "use_bias": true, + "activity_regularizer": null + }, + "inbound_nodes": [ + [ + [ + "dense_2", + 0, + 0, + {} + ] + ] + ], + "name": "dense_3" + }, + { + "class_name": "Length", + "config": { + "trainable": true, + "name": "capsnet" + }, + "inbound_nodes": [ + [ + [ + "digitcaps", + 0, + 0, + {} + ] + ] + ], + "name": "capsnet" + }, + { + "class_name": "Reshape", + "config": { + "target_shape": [ + 28, + 28, + 1 + ], + "trainable": true, + "name": "out_recon" + }, + "inbound_nodes": [ + [ + [ + "dense_3", + 0, + 0, + {} + ] + ] + ], + "name": "out_recon" + } + ], + "input_layers": [ + [ + "Input", + 0, + 0 + ], + [ + "input_1", + 0, + 0 + ] + ], + "output_layers": [ + [ + "capsnet", + 0, + 0 + ], + [ + "out_recon", + 0, + 0 + ] + ], + "name": "model_1" + }, + "backend": "tensorflow" +} \ No newline at end of file diff --git a/ide/static/js/data.js b/ide/static/js/data.js index b9bb5d410..3bb5ec1a1 100644 --- a/ide/static/js/data.js +++ b/ide/static/js/data.js @@ -1343,6 +1343,48 @@ export default { }, learn: true }, + CapsuleLayer: { + name:'capsule_layer', + color:'#ffeb3b', + endpoint:{ + src:['Bottom'], + trg:['Top'] + }, + params: { + num_capsule: { + name:'No. of Capsules', + value: '', + type: 'number', + required: true + }, + dim_capsule: { + name:'Dimension of the Capsule', + value: '', + type: 'number', + required: true + }, + num_routing: { + name: 'No. of routings', + value: '', + type: 'number', + required: true + }, + caffe: { + name: 'Available Caffe', + value: false, + type: 'checkbox', + required: false + } + }, + props: { + name: { + name:'Name', + value: '', + type: 'text' + } + }, + learn: true + }, /* ********** Recurrent Layers ********** */ Recurrent: { // Only Caffe name: 'recurrent', @@ -3065,6 +3107,36 @@ export default { }, learn: true }, + Squash: { + name: 'squash', + color: '#0329f4', + endpoint: { + src: ['Bottom'], + trg: ['Top'] + }, + params: { + axis: { + name: 'Axis', + value: -1, + type: 'number', + required:false + }, + caffe: { + name: 'Available Caffe', + value: false, + type: 'checkbox', + required: false + } + }, + props:{ + name: { + name:'Name', + value: '', + type: 'text' + } + }, + learn: false + }, /* ********** Utility Layers ********** */ Flatten: { name: 'flatten', @@ -3603,6 +3675,54 @@ export default { }, learn: false }, + Length: { + name:'length', + color: '#ffeb3c', + endpoint: { + src:['Bottom'], + trg:['Top'] + }, + params: { + caffe: { + name:'Available Caffe', + value: false, + type: 'checkbox', + required: false + } + }, + props: { + name: { + name: 'Name', + value: '', + type: 'text' + } + }, + learn: false + }, + MaskCapsule: { + name:'mask_capsule', + color: '#ff98c0', + endpoint: { + src:['Bottom'], + trg:['Top'] + }, + params: { + caffe: { + name:'Available Caffe', + value: false, + type: 'checkbox', + required: false + } + }, + props:{ + name: { + name: "Name", + value: '', + type: 'text' + } + }, + learn: false + }, /* ********** Loss Layers ********** */ MultinomialLogisticLoss: { // Only Caffe name: 'multinomial logistic loss', diff --git a/ide/static/js/modelZoo.js b/ide/static/js/modelZoo.js index 320360427..66d2a98bc 100644 --- a/ide/static/js/modelZoo.js +++ b/ide/static/js/modelZoo.js @@ -34,7 +34,10 @@ class ModelZoo extends React.Component {
IMDB CNN LSTM
- SimpleNet + SimpleNet +
+ CapsNet +

Detection

diff --git a/ide/static/js/pane.js b/ide/static/js/pane.js index 2f1f96217..4375b73f9 100644 --- a/ide/static/js/pane.js +++ b/ide/static/js/pane.js @@ -161,6 +161,9 @@ class Pane extends React.Component { Depthwise Convolution + Capsule Layer
@@ -250,6 +253,12 @@ class Pane extends React.Component { Masking + Length + Mask Capsule @@ -319,6 +328,9 @@ class Pane extends React.Component { Scale + Squash diff --git a/keras_app/custom_layers/capsule_layer.py b/keras_app/custom_layers/capsule_layer.py new file mode 100644 index 000000000..28aa6448d --- /dev/null +++ b/keras_app/custom_layers/capsule_layer.py @@ -0,0 +1,60 @@ +from keras.layers.core import Layer +from keras import backend as K +import keras + + +def squash_activation(vectors, axis=-1): + s_squared_norm = K.sum(K.square(vectors), axis, keepdims=True) + scale = s_squared_norm / (1 + s_squared_norm) / K.sqrt(s_squared_norm + 1e-7) + return scale * vectors + + +class CapsuleLayer(Layer): + def __init__(self, num_capsule, dim_capsule, num_routing=3, **kwargs): + super(CapsuleLayer, self).__init__(**kwargs) + self.num_capsule = num_capsule + self.dim_capsule = dim_capsule + self.num_routing = num_routing + self.kernel_initializer = keras.initializers.random_uniform(-1, 1) + self.bias_initializer = keras.initializers.Zeros() + super(CapsuleLayer, self).__init__(**kwargs) + + def build(self, input_shape): + assert len(input_shape) >= 3 + self.W = self.add_weight(shape=[input_shape[1], self.num_capsule, input_shape[2], self.dim_capsule], + initializer=self.kernel_initializer, + name='W') + self.b = self.add_weight(shape=[input_shape[1], self.num_capsule], + initializer=self.bias_initializer, + name='b') + super(CapsuleLayer, self).build(input_shape) + + def call(self, inputs, training=None): + inputs_expand = K.expand_dims(inputs, 2) + inputs_tiled = K.repeat_elements(inputs_expand, self.num_capsule, axis=2) + inputs_hat = K.map_fn(lambda x: K.batch_dot(x, self.W, [2, 2]), inputs_tiled) + input_shape = K.shape(inputs_hat) + b = self.b + b = K.expand_dims(b, axis=0) + assert self.num_routing > 0 + for i in range(self.num_routing): + c = K.softmax(b) + c = K.expand_dims(c, axis=-1) + c = K.repeat_elements(c, rep=self.dim_capsule, axis=-1) + S = K.sum(c * inputs_hat, axis=1) + V = squash_activation(S) + if i != self.num_routing-1: + V_expanded = K.expand_dims(V, axis=1) + V_expanded = K.tile(V_expanded, [1, input_shape[1], 1, 1]) + b = b + K.sum(inputs_hat * V_expanded, axis=-1) + return V + + def compute_output_shape(self, input_shape): + return tuple([None, self.num_capsule, self.dim_capsule]) + + def get_config(self): + base_config = super(CapsuleLayer, self).get_config() + base_config['num_capsule'] = self.num_capsule + base_config['num_routing'] = self.num_routing + base_config['dim_capsule'] = self.dim_capsule + return base_config diff --git a/keras_app/custom_layers/config.py b/keras_app/custom_layers/config.py index 1a6afc315..335d786e2 100644 --- a/keras_app/custom_layers/config.py +++ b/keras_app/custom_layers/config.py @@ -4,5 +4,21 @@ 'LRN': { 'filename': 'lrn.py', 'url': '/media/lrn.py' + }, + 'CapsuleLayer': { + 'filename': 'capsule_layer.py', + 'url': '/media/capsule_layer.py' + }, + 'Length': { + 'filename': 'length.py', + 'url': 'media/length.py' + }, + 'MaskCapsule': { + 'filename': 'mask_capsule.py', + 'url': 'media/mask_capsule.py' + }, + 'Squash': { + 'filename': 'squash.py', + 'url': 'media/squash.py' } } diff --git a/keras_app/custom_layers/length.py b/keras_app/custom_layers/length.py new file mode 100644 index 000000000..ae9bf315e --- /dev/null +++ b/keras_app/custom_layers/length.py @@ -0,0 +1,20 @@ +from keras.layers.core import Layer +from keras import backend as K + + +class Length(Layer): + def __init__(self, **kwargs): + super(Length, self).__init__(**kwargs) + + def build(self, input_shape): + super(Length, self).build(input_shape) + + def call(self, input): + return K.sqrt(K.sum(K.square(input), -1)) + + def compute_output_shape(self, input_shape): + return input_shape[:-1] + + def get_config(self): + base_config = super(Length, self).get_config() + return base_config diff --git a/keras_app/custom_layers/mask_capsule.py b/keras_app/custom_layers/mask_capsule.py new file mode 100644 index 000000000..d7f3ce6e3 --- /dev/null +++ b/keras_app/custom_layers/mask_capsule.py @@ -0,0 +1,29 @@ +from keras.layers.core import Layer +from keras import backend as K + + +class MaskCapsule(Layer): + def __init__(self, **kwargs): + super(MaskCapsule, self).__init__(**kwargs) + + def build(self, input_shape): + super(MaskCapsule, self).build(input_shape) + + def call(self, inputs): + if type(inputs) == list: + assert len(inputs) == 2 + inputs, mask = inputs + else: + x = K.sqrt(K.sum(K.square(inputs), -1)) + mask = K.one_hot(indices=K.argmax(x, 1), num_classes=x.get_shape().as_list()[1]) + masked = K.batch_flatten(inputs*K.expand_dims(mask, -1)) + return masked + + def compute_output_shape(self, input_shape): + if type(input_shape[0]) is tuple: + return tuple([None, input_shape[0][1]*input_shape[0][2]]) + else: + return tuple([None, input_shape[1]*input_shape[2]]) + + def get_config(self): + return super(MaskCapsule, self).get_config() diff --git a/keras_app/custom_layers/squash.py b/keras_app/custom_layers/squash.py new file mode 100644 index 000000000..67cb9d2da --- /dev/null +++ b/keras_app/custom_layers/squash.py @@ -0,0 +1,24 @@ +from keras.layers.core import Layer +from keras import backend as K + + +class Squash(Layer): + def __init__(self, axis=-1, **kwargs): + self.axis = axis + super(Squash, self).__init__(**kwargs) + + def build(self, input_shape): + super(Squash, self).build(input_shape) + + def call(self, inputs): + s_squared_norm = K.sum(K.square(inputs), self.axis, keepdims=True) + scale = s_squared_norm / (1 + s_squared_norm) / K.sqrt(s_squared_norm + 1e-7) + return scale * inputs + + def compute_output_shape(self, input_shape): + return input_shape + + def get_config(self): + base_config = super(Squash, self).get_config() + base_config['axis'] = self.axis + return base_config diff --git a/keras_app/views/export_json.py b/keras_app/views/export_json.py index af8913fea..c0ee6f6ad 100644 --- a/keras_app/views/export_json.py +++ b/keras_app/views/export_json.py @@ -10,7 +10,7 @@ from layers_export import data, convolution, deconvolution, pooling, dense, dropout, embed,\ recurrent, batch_norm, activation, flatten, reshape, eltwise, concat, upsample, locally_connected,\ permute, repeat_vector, regularization, masking, gaussian_noise, gaussian_dropout, alpha_dropout, \ - bidirectional, time_distributed, lrn, depthwiseConv + bidirectional, time_distributed, lrn, depthwiseConv, capsule_layer, length, mask_capsule, squash from ..custom_layers import config as custom_layers_config @@ -81,7 +81,11 @@ def export_json(request, is_tf=False): } custom_layers_map = { - 'LRN': lrn + 'LRN': lrn, + 'CapsuleLayer': capsule_layer, + 'Length': length, + 'MaskCapsule': mask_capsule, + 'Squash': squash } # Remove any duplicate activation layers (timedistributed and bidirectional layers) diff --git a/keras_app/views/import_json.py b/keras_app/views/import_json.py index d8b919884..be29162db 100644 --- a/keras_app/views/import_json.py +++ b/keras_app/views/import_json.py @@ -10,10 +10,14 @@ Recurrent, BatchNorm, Activation, LeakyReLU, PReLU, ELU, Scale, Flatten, Reshape, Concat, \ Eltwise, Padding, Upsample, LocallyConnected, ThresholdedReLU, Permute, RepeatVector,\ ActivityRegularization, Masking, GaussianNoise, GaussianDropout, AlphaDropout, \ - TimeDistributed, Bidirectional, DepthwiseConv, lrn + TimeDistributed, Bidirectional, DepthwiseConv, lrn, capsule_layer, length, mask_capsule, squash from keras.models import model_from_json, Sequential from keras.layers import deserialize from ..custom_layers.lrn import LRN +from ..custom_layers.capsule_layer import CapsuleLayer +from ..custom_layers.length import Length +from ..custom_layers.mask_capsule import MaskCapsule +from ..custom_layers.squash import Squash @csrf_exempt @@ -49,7 +53,9 @@ def import_json(request): except Exception: return JsonResponse({'result': 'error', 'error': 'Invalid JSON'}) - model = model_from_json(json.dumps(model), custom_objects={'LRN': LRN}) + model = model_from_json(json.dumps(model), + custom_objects={'LRN': LRN, 'Length': Length, 'MaskCapsule': MaskCapsule, + 'Squash': Squash, 'CapsuleLayer': CapsuleLayer}) layer_map = { 'InputLayer': Input, 'Dense': Dense, @@ -113,7 +119,11 @@ def import_json(request): 'AlphaDropout': AlphaDropout, 'TimeDistributed': TimeDistributed, 'Bidirectional': Bidirectional, - 'LRN': lrn + 'LRN': lrn, + 'CapsuleLayer': capsule_layer, + 'Length': length, + 'MaskCapsule': mask_capsule, + 'Squash': squash } hasActivation = ['Conv1D', 'Conv2D', 'Conv3D', 'Conv2DTranspose', 'Dense', 'LocallyConnected1D', diff --git a/keras_app/views/layers_export.py b/keras_app/views/layers_export.py index 257065610..f82c3aa6e 100644 --- a/keras_app/views/layers_export.py +++ b/keras_app/views/layers_export.py @@ -18,6 +18,10 @@ from keras.layers import TimeDistributed, Bidirectional from keras import regularizers from ..custom_layers.lrn import LRN +from ..custom_layers.capsule_layer import CapsuleLayer +from ..custom_layers.length import Length +from ..custom_layers.mask_capsule import MaskCapsule +from ..custom_layers.squash import Squash fillerMap = { 'constant': 'Constant', @@ -128,6 +132,12 @@ def activation(layer, layer_in, layerId, tensor=True): return out +def squash(layer, layer_in, layerId): + axis = layer['params']['axis'] + out = {} + out[layerId] = Squash(axis=axis)(*layer_in) + + def dropout(layer, layer_in, layerId, tensor=True): out = {layerId: Dropout(0.5)} if tensor: @@ -180,6 +190,18 @@ def masking(layer, layer_in, layerId, tensor=True): return out +def length(layer, layer_in, layerId): + out = {} + out[layerId] = Length()(*layer_in) + return out + + +def mask_capsule(layer, layer_in, layerId): + out = {} + out[layerId] = MaskCapsule()(*layer_in) + return out + + # ********** Convolution Layers ********** def convolution(layer, layer_in, layerId, tensor=True): convMap = { @@ -366,6 +388,17 @@ def upsample(layer, layer_in, layerId, tensor=True): return out +# ********** Capsule Layers ********** +def capsule_layer(layer, layer_in, layerId): + num_capsule = layer['params']['num_capsule'] + dim_capsule = layer['params']['dim_capsule'] + num_routing = layer['params']['num_routing'] + out = {} + out[layerId] = CapsuleLayer(num_capsule=num_capsule, dim_capsule=dim_capsule, + num_routing=num_routing)(*layer_in) + return out + + # ********** Pooling Layers ********** def pooling(layer, layer_in, layerId, tensor=True): poolMap = { diff --git a/keras_app/views/layers_import.py b/keras_app/views/layers_import.py index 7be30f85c..508238a02 100644 --- a/keras_app/views/layers_import.py +++ b/keras_app/views/layers_import.py @@ -52,6 +52,12 @@ def Activation(layer): return jsonLayer(activationMap[layer.activation.func_name], {}, tempLayer) +def squash(layer): + params = {} + params['axis'] = layer.axis + return jsonLayer('Squash', params, layer) + + def Dropout(layer): params = {} if (layer.rate is not None): @@ -99,6 +105,16 @@ def Masking(layer): return jsonLayer('Masking', params, layer) +def length(layer): + params = {} + return jsonLayer('Length', params, layer) + + +def mask_capsule(layer): + params = {} + return jsonLayer('MaskCapsule', params, layer) + + # ********** Convolutional Layers ********** def Convolution(layer): params = {} @@ -225,6 +241,15 @@ def Upsample(layer): return jsonLayer('Upsample', params, layer) +# ********** Capsule Layers ********** +def capsule_layer(layer): + params = {} + params['num_capsule'] = layer.num_capsule + params['dim_capsule'] = layer.dim_capsule + params['num_routing'] = layer.num_routing + return jsonLayer('CapsuleLayer', params, layer) + + # ********** Pooling Layers ********** def Pooling(layer): params = {} From 2d55052709e920461d437acbbbaf3e31e6cdc6c1 Mon Sep 17 00:00:00 2001 From: namish800 Date: Mon, 5 Nov 2018 17:37:25 +0530 Subject: [PATCH 02/12] Added shape calculation logic for custom layers --- README.md | 2 +- ide/tasks.py | 13 +++++++++--- ide/utils/shapes.py | 27 +++++++++++++++++++++++- keras_app/custom_layers/capsule_layer.py | 5 +++++ keras_app/views/layers_export.py | 1 + 5 files changed, 43 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 8fc20e8b5..4b3da0582 100644 --- a/README.md +++ b/README.md @@ -291,7 +291,7 @@ Models | Ca [Pix2Pix](https://github.com/phillipi/pix2pix) | √ | × | × | [VQA](https://github.com/iamaaditya/VQA_Demo) | √ | √ | √ | [Denoising Auto-Encoder](https://blog.keras.io/building-autoencoders-in-keras.html) | × | √ | √ | -[CapsNet](https://arxiv.org/abs/1710.09829) | × | √ | √ | +[CapsNet](https://arxiv.org/abs/1710.09829) | × | √ | × | Note: For models that use a custom LRN layer (Alexnet), Keras expects the custom layer to be passed when it is loaded from json. LRN.py is located in keras_app/custom_layers. [Alexnet import for Keras](https://github.com/Cloud-CV/Fabrik/blob/master/tutorials/keras_custom_layer_usage.md) diff --git a/ide/tasks.py b/ide/tasks.py index ecc46fa0c..f81eb55ea 100644 --- a/ide/tasks.py +++ b/ide/tasks.py @@ -13,7 +13,7 @@ from keras_app.views.layers_export import data, convolution, deconvolution, pooling, dense, dropout, embed,\ recurrent, batch_norm, activation, flatten, reshape, eltwise, concat, upsample, locally_connected,\ permute, repeat_vector, regularization, masking, gaussian_noise, gaussian_dropout, alpha_dropout, \ - bidirectional, time_distributed, lrn, depthwiseConv + bidirectional, time_distributed, lrn, depthwiseConv, capsule_layer, squash, length, mask_capsule from keras_app.custom_layers import config as custom_layers_config from keras.models import model_from_json import tensorflow as tf @@ -110,7 +110,11 @@ def export_keras_json(net, net_name, is_tf, reply_channel): } custom_layers_map = { - 'LRN': lrn + 'LRN': lrn, + 'CapsuleLayer': capsule_layer, + 'Length': length, + 'MaskCapsule': mask_capsule, + 'Squash': squash } # Remove any duplicate activation layers (timedistributed and bidirectional layers) @@ -199,7 +203,6 @@ def isProcessPossible(layerId): }) }) return - while(len(stack)): if ('Loss' in net[layerId]['info']['type'] or net[layerId]['info']['type'] == 'Accuracy'): @@ -213,6 +216,10 @@ def isProcessPossible(layerId): if (net[layerId]['info']['type'] != 'Scale'): layer_in = [net_out[inputId] for inputId in net[layerId]['connection']['input']] + # Handling MaskCapsule layer seperately + if (net[layerId]['info']['type'] == 'MaskCapsule'): + layer_in = [[net_out[inputId] + for inputId in net[layerId]['connection']['input']]] # Need to check if next layer is Scale if (net[layerId]['info']['type'] == 'BatchNorm'): idNext = net[layerId]['connection']['output'][0] diff --git a/ide/utils/shapes.py b/ide/utils/shapes.py index 34da58860..5c1c26eb8 100644 --- a/ide/utils/shapes.py +++ b/ide/utils/shapes.py @@ -139,6 +139,15 @@ def repeat(layer): return shape +def capsule(layer): + if (layer['info']['type'] == "CapsuleLayer"): + return [layer['params']['dim_capsule'], layer['params']['num_capsule']] + elif (layer['info']['type'] == "MaskCapsule"): + return [layer['shape']['input'][0][0] * layer['shape']['input'][0][1]] + else: + return [layer['shape']['input'][0]] + + def handle_concat_layer(outputLayer, inputLayer): if('input' not in outputLayer['shape']): shape = inputLayer['shape']['output'][:] @@ -149,6 +158,17 @@ def handle_concat_layer(outputLayer, inputLayer): return shape +def handle_mask_capsule_layer_input(inlayer, masklayer): + if inlayer['info']['type'] == "CapsuleLayer": + shape = inlayer['shape']['output'][:] + return shape + else: + shape = [] + shape.append(masklayer['shape']['input'][:]) + shape.append(inlayer['shape']['output'][:]) + return shape + + def get_layer_shape(layer): # separating checking the type of layer inorder to make it modular # which can be reused in case we only want to get shapes of a single @@ -161,6 +181,9 @@ def get_layer_shape(layer): elif(layer['info']['type'] in ['Convolution', 'Pooling', 'Deconvolution', 'DepthwiseConv']): return filter(layer) + elif(layer['info']['type'] in ['CapsuleLayer', 'Length', 'MaskCapsule']): + return capsule(layer) + elif(layer['info']['type'] in ['InnerProduct', 'Recurrent', 'RNN', 'LSTM', 'Embed']): return output(layer) @@ -208,7 +231,6 @@ def get_shapes(net): while(len(queue)): # using deque as stack layerId = queue.pop() - if(net[layerId]['info']['type'] in dataLayers): net[layerId]['shape']['input'], net[layerId]['shape']['output'] = get_layer_shape(net[layerId]) else: @@ -219,6 +241,9 @@ def get_shapes(net): # Handling Concat layer separately if (net[outputId]['info']['type'] == "Concat"): net[outputId]['shape']['input'] = handle_concat_layer(net[outputId], net[layerId]) + elif (net[outputId]['info']['type'] == "MaskCapsule"): + net[outputId]['shape']['input'] = handle_mask_capsule_layer_input(net[layerId], + net[outputId]) else: net[outputId]['shape']['input'] = net[layerId]['shape']['output'][:] diff --git a/keras_app/custom_layers/capsule_layer.py b/keras_app/custom_layers/capsule_layer.py index 28aa6448d..41bf36019 100644 --- a/keras_app/custom_layers/capsule_layer.py +++ b/keras_app/custom_layers/capsule_layer.py @@ -27,6 +27,9 @@ def build(self, input_shape): self.b = self.add_weight(shape=[input_shape[1], self.num_capsule], initializer=self.bias_initializer, name='b') + self.c = self.add_weight(shape=[input_shape[1], self.num_capsule], + initializer=self.bias_initializer, + name='c') super(CapsuleLayer, self).build(input_shape) def call(self, inputs, training=None): @@ -36,6 +39,8 @@ def call(self, inputs, training=None): input_shape = K.shape(inputs_hat) b = self.b b = K.expand_dims(b, axis=0) + c = self.c + c = K.expand_dims(c, axis=0) assert self.num_routing > 0 for i in range(self.num_routing): c = K.softmax(b) diff --git a/keras_app/views/layers_export.py b/keras_app/views/layers_export.py index f82c3aa6e..5d2b81c23 100644 --- a/keras_app/views/layers_export.py +++ b/keras_app/views/layers_export.py @@ -136,6 +136,7 @@ def squash(layer, layer_in, layerId): axis = layer['params']['axis'] out = {} out[layerId] = Squash(axis=axis)(*layer_in) + return out def dropout(layer, layer_in, layerId, tensor=True): From 7da7f1017fb1daab88823122ada6f1b2d2d45ed5 Mon Sep 17 00:00:00 2001 From: namish800 Date: Mon, 5 Nov 2018 23:19:02 +0530 Subject: [PATCH 03/12] Corrected the modelname in the frontend --- example/keras/Capsnet.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/example/keras/Capsnet.json b/example/keras/Capsnet.json index d9ceda43f..5cfa174c9 100644 --- a/example/keras/Capsnet.json +++ b/example/keras/Capsnet.json @@ -408,7 +408,7 @@ 0 ] ], - "name": "model_1" + "name": "CapsNet" }, "backend": "tensorflow" } \ No newline at end of file From 27728d532b1b925e8af760d91790208e1154e3e3 Mon Sep 17 00:00:00 2001 From: namish800 Date: Wed, 7 Nov 2018 13:24:29 +0530 Subject: [PATCH 04/12] Added import export test for capsule layers --- tests/unit/keras_app/test_views.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/tests/unit/keras_app/test_views.py b/tests/unit/keras_app/test_views.py index c21b420ff..abaa531fa 100644 --- a/tests/unit/keras_app/test_views.py +++ b/tests/unit/keras_app/test_views.py @@ -697,6 +697,23 @@ def test_keras_import(self): self.pad_test(model, 'pad_w', 2) +# **********Capsule Layers ************** +class CapsuleLayerTest(unittest.TestCase, HelperFunctions): + def setUp(self): + self.client = Client() + + def test_keras_import_export(self): + model_file = open(os.path.join(settings.BASE_DIR, 'example/keras', + 'Capsnet.json'), 'r') + response = self.client.post(reverse('keras-import'), {'file': model_file}) + response = json.loads(response.content) + net = get_shapes(response['net']) + response = self.client.post(reverse('keras-export'), {'net': json.dumps(net), + 'net_name': ''}) + response = json.loads(response.content) + self.assertEqual(response['result'], 'success') + + # ********** Export json tests ********** # ********** Data Layers Test ********** From bcb8a51634bfe2f85afec14b22823a4af93d29c9 Mon Sep 17 00:00:00 2001 From: namish800 Date: Wed, 7 Nov 2018 13:45:49 +0530 Subject: [PATCH 05/12] Fixed layer input for MaskCapsule layer --- keras_app/views/export_json.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/keras_app/views/export_json.py b/keras_app/views/export_json.py index df9880074..8ff3db3aa 100644 --- a/keras_app/views/export_json.py +++ b/keras_app/views/export_json.py @@ -175,6 +175,9 @@ def isProcessPossible(layerId): if (net[layerId]['info']['type'] != 'Scale'): layer_in = [net_out[inputId] for inputId in net[layerId]['connection']['input']] + if (net[layerId]['info']['type'] == 'MaskCapsule'): + layer_in = [[net_out[inputId] + for inputId in net[layerId]['connection']['input']]] # Need to check if next layer is Scale if (net[layerId]['info']['type'] == 'BatchNorm'): idNext = net[layerId]['connection']['output'][0] From 029e01104e9f6213fb63709a75b68f721c987c49 Mon Sep 17 00:00:00 2001 From: namish800 Date: Fri, 9 Nov 2018 01:11:00 +0530 Subject: [PATCH 06/12] *Added support for tensorflow export *Indicated about the same in README.md --- README.md | 2 +- ide/tasks.py | 10 +++++++++- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 4b3da0582..8fc20e8b5 100644 --- a/README.md +++ b/README.md @@ -291,7 +291,7 @@ Models | Ca [Pix2Pix](https://github.com/phillipi/pix2pix) | √ | × | × | [VQA](https://github.com/iamaaditya/VQA_Demo) | √ | √ | √ | [Denoising Auto-Encoder](https://blog.keras.io/building-autoencoders-in-keras.html) | × | √ | √ | -[CapsNet](https://arxiv.org/abs/1710.09829) | × | √ | × | +[CapsNet](https://arxiv.org/abs/1710.09829) | × | √ | √ | Note: For models that use a custom LRN layer (Alexnet), Keras expects the custom layer to be passed when it is loaded from json. LRN.py is located in keras_app/custom_layers. [Alexnet import for Keras](https://github.com/Cloud-CV/Fabrik/blob/master/tutorials/keras_custom_layer_usage.md) diff --git a/ide/tasks.py b/ide/tasks.py index 33a8b0aea..6bb14ee9a 100644 --- a/ide/tasks.py +++ b/ide/tasks.py @@ -317,8 +317,16 @@ def isProcessPossible(layerId): json_str = json_str.strip("'<>() ").replace('\'', '\"') lrnLayer = imp.load_source('LRN', BASE_DIR + '/keras_app/custom_layers/lrn.py') + capsuleLayer = imp.load_source('CapsuleLayer', BASE_DIR + '/keras_app/custom_layers/capsule_layer.py') + maskcapsuleLayer = imp.load_source('MaskCapsule', + BASE_DIR + '/keras_app/custom_layers/mask_capsule.py') + squashLayer = imp.load_source('Squash', BASE_DIR + '/keras_app/custom_layers/squash.py') + lengthLayer = imp.load_source('Length', BASE_DIR + '/keras_app/custom_layers/length.py') - model = model_from_json(json_str, {'LRN': lrnLayer.LRN}) + model = model_from_json(json_str, {'LRN': lrnLayer.LRN, 'CapsuleLayer': capsuleLayer.CapsuleLayer, + 'MaskCapsule': maskcapsuleLayer.MaskCapsule, + 'Length': lengthLayer.Length, + 'Squash': squashLayer.Squash}) sess = K.get_session() tf.train.write_graph(sess.graph.as_graph_def(add_shapes=True), output_fld, From 715c31b5263f52dcb1220ac8a2920d1ec5e0b3f1 Mon Sep 17 00:00:00 2001 From: namish800 Date: Fri, 9 Nov 2018 01:53:33 +0530 Subject: [PATCH 07/12] *Added support for Capsule net layers in tensorflow. *Added import and export test for Capsnet in tensorflow. --- example/tensorflow/Capsulelayers.pbtxt | 24587 ++++++++++++++++++++++ tensorflow_app/views/import_graphdef.py | 24 +- tensorflow_app/views/json2pbtxt.py | 9 +- tests/unit/tensorflow_app/test_views.py | 23 + 4 files changed, 24640 insertions(+), 3 deletions(-) create mode 100644 example/tensorflow/Capsulelayers.pbtxt diff --git a/example/tensorflow/Capsulelayers.pbtxt b/example/tensorflow/Capsulelayers.pbtxt new file mode 100644 index 000000000..94d43bef2 --- /dev/null +++ b/example/tensorflow/Capsulelayers.pbtxt @@ -0,0 +1,24587 @@ +node { + name: "input_1" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + } + } + } +} +node { + name: "input_2" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 28 + } + dim { + size: 28 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 28 + } + dim { + size: 28 + } + dim { + size: 1 + } + } + } + } +} +node { + name: "conv2d_1/truncated_normal/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\t\000\000\000\t\000\000\000\001\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "conv2d_1/truncated_normal/mean" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "conv2d_1/truncated_normal/stddev" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.111111111939 + } + } + } +} +node { + name: "conv2d_1/truncated_normal/TruncatedNormal" + op: "TruncatedNormal" + input: "conv2d_1/truncated_normal/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 1 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 87654321 + } + } + attr { + key: "seed2" + value { + i: 763311 + } + } +} +node { + name: "conv2d_1/truncated_normal/mul" + op: "Mul" + input: "conv2d_1/truncated_normal/TruncatedNormal" + input: "conv2d_1/truncated_normal/stddev" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 1 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_1/truncated_normal" + op: "Add" + input: "conv2d_1/truncated_normal/mul" + input: "conv2d_1/truncated_normal/mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 1 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_1/kernel" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 1 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 1 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "conv2d_1/kernel/Assign" + op: "Assign" + input: "conv2d_1/kernel" + input: "conv2d_1/truncated_normal" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_1/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 1 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "conv2d_1/kernel/read" + op: "Identity" + input: "conv2d_1/kernel" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_1/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 1 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "conv2d_1/bias" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "conv2d_1/bias/Assign" + op: "Assign" + input: "conv2d_1/bias" + input: "conv2d_1/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_1/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "conv2d_1/bias/read" + op: "Identity" + input: "conv2d_1/bias" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_1/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_1/convolution/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "conv2d_1/convolution" + op: "Conv2D" + input: "input_2" + input: "conv2d_1/kernel/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 20 + } + dim { + size: 20 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "padding" + value { + s: "VALID" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "conv2d_1/BiasAdd" + op: "BiasAdd" + input: "conv2d_1/convolution" + input: "conv2d_1/bias/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 20 + } + dim { + size: 20 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "activation_1/Relu" + op: "Relu" + input: "conv2d_1/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 20 + } + dim { + size: 20 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_2/truncated_normal/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\t\000\000\000\t\000\000\000\000\001\000\000\000\001\000\000" + } + } + } +} +node { + name: "conv2d_2/truncated_normal/mean" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "conv2d_2/truncated_normal/stddev" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.00694444449618 + } + } + } +} +node { + name: "conv2d_2/truncated_normal/TruncatedNormal" + op: "TruncatedNormal" + input: "conv2d_2/truncated_normal/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 87654321 + } + } + attr { + key: "seed2" + value { + i: 6872 + } + } +} +node { + name: "conv2d_2/truncated_normal/mul" + op: "Mul" + input: "conv2d_2/truncated_normal/TruncatedNormal" + input: "conv2d_2/truncated_normal/stddev" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_2/truncated_normal" + op: "Add" + input: "conv2d_2/truncated_normal/mul" + input: "conv2d_2/truncated_normal/mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_2/kernel" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "conv2d_2/kernel/Assign" + op: "Assign" + input: "conv2d_2/kernel" + input: "conv2d_2/truncated_normal" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_2/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "conv2d_2/kernel/read" + op: "Identity" + input: "conv2d_2/kernel" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_2/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_2/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "conv2d_2/bias" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "conv2d_2/bias/Assign" + op: "Assign" + input: "conv2d_2/bias" + input: "conv2d_2/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_2/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "conv2d_2/bias/read" + op: "Identity" + input: "conv2d_2/bias" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_2/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_2/convolution/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "conv2d_2/convolution" + op: "Conv2D" + input: "activation_1/Relu" + input: "conv2d_2/kernel/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 6 + } + dim { + size: 6 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "padding" + value { + s: "VALID" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "conv2d_2/BiasAdd" + op: "BiasAdd" + input: "conv2d_2/convolution" + input: "conv2d_2/bias/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 6 + } + dim { + size: 6 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "reshape_1/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\010\000\000\000\200\004\000\000" + } + } + } +} +node { + name: "reshape_1/Reshape" + op: "Reshape" + input: "conv2d_2/BiasAdd" + input: "reshape_1/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1152 + } + } + } + } + } +} +node { + name: "squash_1/Square" + op: "Square" + input: "reshape_1/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1152 + } + } + } + } + } +} +node { + name: "squash_1/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "squash_1/Sum" + op: "Sum" + input: "squash_1/Square" + input: "squash_1/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } +} +node { + name: "squash_1/add/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "squash_1/add" + op: "Add" + input: "squash_1/add/x" + input: "squash_1/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "squash_1/div" + op: "RealDiv" + input: "squash_1/Sum" + input: "squash_1/add" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "squash_1/add_1/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.00000001169e-07 + } + } + } +} +node { + name: "squash_1/add_1" + op: "Add" + input: "squash_1/Sum" + input: "squash_1/add_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "squash_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "squash_1/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: inf + } + } + } +} +node { + name: "squash_1/clip_by_value/Minimum" + op: "Minimum" + input: "squash_1/add_1" + input: "squash_1/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "squash_1/clip_by_value" + op: "Maximum" + input: "squash_1/clip_by_value/Minimum" + input: "squash_1/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "squash_1/Sqrt" + op: "Sqrt" + input: "squash_1/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "squash_1/div_1" + op: "RealDiv" + input: "squash_1/div" + input: "squash_1/Sqrt" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "squash_1/mul" + op: "Mul" + input: "squash_1/div_1" + input: "reshape_1/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1152 + } + } + } + } + } +} +node { + name: "capsule_layer_2/random_uniform/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\010\000\000\000\n\000\000\000\200\004\000\000\020\000\000\000" + } + } + } +} +node { + name: "capsule_layer_2/random_uniform/min" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -1.0 + } + } + } +} +node { + name: "capsule_layer_2/random_uniform/max" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "capsule_layer_2/random_uniform/RandomUniform" + op: "RandomUniform" + input: "capsule_layer_2/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 87654321 + } + } + attr { + key: "seed2" + value { + i: 4014443 + } + } +} +node { + name: "capsule_layer_2/random_uniform/sub" + op: "Sub" + input: "capsule_layer_2/random_uniform/max" + input: "capsule_layer_2/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/random_uniform/mul" + op: "Mul" + input: "capsule_layer_2/random_uniform/RandomUniform" + input: "capsule_layer_2/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/random_uniform" + op: "Add" + input: "capsule_layer_2/random_uniform/mul" + input: "capsule_layer_2/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/W" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "capsule_layer_2/W/Assign" + op: "Assign" + input: "capsule_layer_2/W" + input: "capsule_layer_2/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/W" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "capsule_layer_2/W/read" + op: "Identity" + input: "capsule_layer_2/W" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/W" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "capsule_layer_2/b" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "capsule_layer_2/b/Assign" + op: "Assign" + input: "capsule_layer_2/b" + input: "capsule_layer_2/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/b" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "capsule_layer_2/b/read" + op: "Identity" + input: "capsule_layer_2/b" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/b" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "capsule_layer_2/c" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "capsule_layer_2/c/Assign" + op: "Assign" + input: "capsule_layer_2/c" + input: "capsule_layer_2/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/c" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "capsule_layer_2/c/read" + op: "Identity" + input: "capsule_layer_2/c" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/c" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims" + op: "ExpandDims" + input: "squash_1/mul" + input: "capsule_layer_2/ExpandDims/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + dim { + size: 1152 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Const_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/split/split_dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "capsule_layer_2/split" + op: "Split" + input: "capsule_layer_2/split/split_dim" + input: "capsule_layer_2/ExpandDims" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + dim { + size: 1152 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "capsule_layer_2/concat" + op: "ConcatV2" + input: "capsule_layer_2/split" + input: "capsule_layer_2/split" + input: "capsule_layer_2/split" + input: "capsule_layer_2/split" + input: "capsule_layer_2/split" + input: "capsule_layer_2/split" + input: "capsule_layer_2/split" + input: "capsule_layer_2/split" + input: "capsule_layer_2/split" + input: "capsule_layer_2/split" + input: "capsule_layer_2/concat/axis" + attr { + key: "N" + value { + i: 10 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + } + } + } + } +} +node { + name: "capsule_layer_2/map/Shape" + op: "Shape" + input: "capsule_layer_2/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "capsule_layer_2/map/strided_slice/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2/map/strided_slice/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/map/strided_slice/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/map/strided_slice" + op: "StridedSlice" + input: "capsule_layer_2/map/Shape" + input: "capsule_layer_2/map/strided_slice/stack" + input: "capsule_layer_2/map/strided_slice/stack_1" + input: "capsule_layer_2/map/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2/map/TensorArray" + op: "TensorArrayV3" + input: "capsule_layer_2/map/strided_slice" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + shape { + } + } + } + } + attr { + key: "clear_after_read" + value { + b: true + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "dynamic_size" + value { + b: false + } + } + attr { + key: "element_shape" + value { + shape { + unknown_rank: true + } + } + } + attr { + key: "tensor_array_name" + value { + s: "" + } + } +} +node { + name: "capsule_layer_2/map/TensorArrayUnstack/Shape" + op: "Shape" + input: "capsule_layer_2/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "capsule_layer_2/map/TensorArrayUnstack/strided_slice/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2/map/TensorArrayUnstack/strided_slice/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/map/TensorArrayUnstack/strided_slice/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/map/TensorArrayUnstack/strided_slice" + op: "StridedSlice" + input: "capsule_layer_2/map/TensorArrayUnstack/Shape" + input: "capsule_layer_2/map/TensorArrayUnstack/strided_slice/stack" + input: "capsule_layer_2/map/TensorArrayUnstack/strided_slice/stack_1" + input: "capsule_layer_2/map/TensorArrayUnstack/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2/map/TensorArrayUnstack/range/start" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2/map/TensorArrayUnstack/range/delta" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/map/TensorArrayUnstack/range" + op: "Range" + input: "capsule_layer_2/map/TensorArrayUnstack/range/start" + input: "capsule_layer_2/map/TensorArrayUnstack/strided_slice" + input: "capsule_layer_2/map/TensorArrayUnstack/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/map/TensorArrayUnstack/TensorArrayScatter/TensorArrayScatterV3" + op: "TensorArrayScatterV3" + input: "capsule_layer_2/map/TensorArray" + input: "capsule_layer_2/map/TensorArrayUnstack/range" + input: "capsule_layer_2/concat" + input: "capsule_layer_2/map/TensorArray:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/concat" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2/map/TensorArray_1" + op: "TensorArrayV3" + input: "capsule_layer_2/map/strided_slice" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + shape { + } + } + } + } + attr { + key: "clear_after_read" + value { + b: true + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "dynamic_size" + value { + b: false + } + } + attr { + key: "element_shape" + value { + shape { + unknown_rank: true + } + } + } + attr { + key: "tensor_array_name" + value { + s: "" + } + } +} +node { + name: "capsule_layer_2/map/while/Enter" + op: "Enter" + input: "capsule_layer_2/map/Const" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "frame_name" + value { + s: "capsule_layer_2/map/while/while_context" + } + } + attr { + key: "is_constant" + value { + b: false + } + } + attr { + key: "parallel_iterations" + value { + i: 10 + } + } +} +node { + name: "capsule_layer_2/map/while/Enter_1" + op: "Enter" + input: "capsule_layer_2/map/TensorArray_1:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "frame_name" + value { + s: "capsule_layer_2/map/while/while_context" + } + } + attr { + key: "is_constant" + value { + b: false + } + } + attr { + key: "parallel_iterations" + value { + i: 10 + } + } +} +node { + name: "capsule_layer_2/map/while/Merge" + op: "Merge" + input: "capsule_layer_2/map/while/Enter" + input: "capsule_layer_2/map/while/NextIteration" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/Merge_1" + op: "Merge" + input: "capsule_layer_2/map/while/Enter_1" + input: "capsule_layer_2/map/while/NextIteration_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/Less/Enter" + op: "Enter" + input: "capsule_layer_2/map/strided_slice" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "frame_name" + value { + s: "capsule_layer_2/map/while/while_context" + } + } + attr { + key: "is_constant" + value { + b: true + } + } + attr { + key: "parallel_iterations" + value { + i: 10 + } + } +} +node { + name: "capsule_layer_2/map/while/Less" + op: "Less" + input: "capsule_layer_2/map/while/Merge" + input: "capsule_layer_2/map/while/Less/Enter" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/LoopCond" + op: "LoopCond" + input: "capsule_layer_2/map/while/Less" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/Switch" + op: "Switch" + input: "capsule_layer_2/map/while/Merge" + input: "capsule_layer_2/map/while/LoopCond" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/map/while/Merge" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/Switch_1" + op: "Switch" + input: "capsule_layer_2/map/while/Merge_1" + input: "capsule_layer_2/map/while/LoopCond" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/map/while/Merge_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/Identity" + op: "Identity" + input: "capsule_layer_2/map/while/Switch:1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/Identity_1" + op: "Identity" + input: "capsule_layer_2/map/while/Switch_1:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/TensorArrayReadV3/Enter" + op: "Enter" + input: "capsule_layer_2/map/TensorArray" + attr { + key: "T" + value { + type: DT_RESOURCE + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "frame_name" + value { + s: "capsule_layer_2/map/while/while_context" + } + } + attr { + key: "is_constant" + value { + b: true + } + } + attr { + key: "parallel_iterations" + value { + i: 10 + } + } +} +node { + name: "capsule_layer_2/map/while/TensorArrayReadV3/Enter_1" + op: "Enter" + input: "capsule_layer_2/map/TensorArrayUnstack/TensorArrayScatter/TensorArrayScatterV3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "frame_name" + value { + s: "capsule_layer_2/map/while/while_context" + } + } + attr { + key: "is_constant" + value { + b: true + } + } + attr { + key: "parallel_iterations" + value { + i: 10 + } + } +} +node { + name: "capsule_layer_2/map/while/TensorArrayReadV3" + op: "TensorArrayReadV3" + input: "capsule_layer_2/map/while/TensorArrayReadV3/Enter" + input: "capsule_layer_2/map/while/Identity" + input: "capsule_layer_2/map/while/TensorArrayReadV3/Enter_1" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "capsule_layer_2/map/while/Shape" + op: "Const" + input: "^capsule_layer_2/map/while/Identity" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\010\000\000\000\n\000\000\000\200\004\000\000" + } + } + } +} +node { + name: "capsule_layer_2/map/while/concat/values_1" + op: "Const" + input: "^capsule_layer_2/map/while/Identity" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/map/while/concat/axis" + op: "Const" + input: "^capsule_layer_2/map/while/Identity" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2/map/while/concat" + op: "ConcatV2" + input: "capsule_layer_2/map/while/Shape" + input: "capsule_layer_2/map/while/concat/values_1" + input: "capsule_layer_2/map/while/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/Reshape" + op: "Reshape" + input: "capsule_layer_2/map/while/TensorArrayReadV3" + input: "capsule_layer_2/map/while/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/MatMul/Enter" + op: "Enter" + input: "capsule_layer_2/W/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "frame_name" + value { + s: "capsule_layer_2/map/while/while_context" + } + } + attr { + key: "is_constant" + value { + b: true + } + } + attr { + key: "parallel_iterations" + value { + i: 10 + } + } +} +node { + name: "capsule_layer_2/map/while/MatMul" + op: "BatchMatMul" + input: "capsule_layer_2/map/while/Reshape" + input: "capsule_layer_2/map/while/MatMul/Enter" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "capsule_layer_2/map/while/Squeeze" + op: "Squeeze" + input: "capsule_layer_2/map/while/MatMul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 2 + } + } + } +} +node { + name: "capsule_layer_2/map/while/TensorArrayWrite/TensorArrayWriteV3/Enter" + op: "Enter" + input: "capsule_layer_2/map/TensorArray_1" + attr { + key: "T" + value { + type: DT_RESOURCE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/map/while/Squeeze" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "frame_name" + value { + s: "capsule_layer_2/map/while/while_context" + } + } + attr { + key: "is_constant" + value { + b: true + } + } + attr { + key: "parallel_iterations" + value { + i: 10 + } + } +} +node { + name: "capsule_layer_2/map/while/TensorArrayWrite/TensorArrayWriteV3" + op: "TensorArrayWriteV3" + input: "capsule_layer_2/map/while/TensorArrayWrite/TensorArrayWriteV3/Enter" + input: "capsule_layer_2/map/while/Identity" + input: "capsule_layer_2/map/while/Squeeze" + input: "capsule_layer_2/map/while/Identity_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/map/while/Squeeze" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/add/y" + op: "Const" + input: "^capsule_layer_2/map/while/Identity" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/map/while/add" + op: "Add" + input: "capsule_layer_2/map/while/Identity" + input: "capsule_layer_2/map/while/add/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/NextIteration" + op: "NextIteration" + input: "capsule_layer_2/map/while/add" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/NextIteration_1" + op: "NextIteration" + input: "capsule_layer_2/map/while/TensorArrayWrite/TensorArrayWriteV3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/Exit" + op: "Exit" + input: "capsule_layer_2/map/while/Switch" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/while/Exit_1" + op: "Exit" + input: "capsule_layer_2/map/while/Switch_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/TensorArrayStack/TensorArraySizeV3" + op: "TensorArraySizeV3" + input: "capsule_layer_2/map/TensorArray_1" + input: "capsule_layer_2/map/while/Exit_1" + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/map/TensorArray_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/map/TensorArrayStack/range/start" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/map/TensorArray_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2/map/TensorArrayStack/range/delta" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/map/TensorArray_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/map/TensorArrayStack/range" + op: "Range" + input: "capsule_layer_2/map/TensorArrayStack/range/start" + input: "capsule_layer_2/map/TensorArrayStack/TensorArraySizeV3" + input: "capsule_layer_2/map/TensorArrayStack/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/map/TensorArray_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/map/TensorArrayStack/TensorArrayGatherV3" + op: "TensorArrayGatherV3" + input: "capsule_layer_2/map/TensorArray_1" + input: "capsule_layer_2/map/TensorArrayStack/range" + input: "capsule_layer_2/map/while/Exit_1" + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2/map/TensorArray_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "element_shape" + value { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } +} +node { + name: "capsule_layer_2/Shape" + op: "Shape" + input: "capsule_layer_2/map/TensorArrayStack/TensorArrayGatherV3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "capsule_layer_2/ExpandDims_1/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims_1" + op: "ExpandDims" + input: "capsule_layer_2/b/read" + input: "capsule_layer_2/ExpandDims_1/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims_2/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims_2" + op: "ExpandDims" + input: "capsule_layer_2/c/read" + input: "capsule_layer_2/ExpandDims_2/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\010\000\000\000\n\000\000\000" + } + } + } +} +node { + name: "capsule_layer_2/Rank" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "capsule_layer_2/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\010\000\000\000\n\000\000\000" + } + } + } +} +node { + name: "capsule_layer_2/Sub/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Sub" + op: "Sub" + input: "capsule_layer_2/Rank" + input: "capsule_layer_2/Sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/Slice/begin" + op: "Pack" + input: "capsule_layer_2/Sub" + attr { + key: "N" + value { + i: 1 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "capsule_layer_2/Slice/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Slice" + op: "Slice" + input: "capsule_layer_2/Shape_2" + input: "capsule_layer_2/Slice/begin" + input: "capsule_layer_2/Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/concat_1/values_0" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2/concat_1/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2/concat_1" + op: "ConcatV2" + input: "capsule_layer_2/concat_1/values_0" + input: "capsule_layer_2/Slice" + input: "capsule_layer_2/concat_1/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Reshape" + op: "Reshape" + input: "capsule_layer_2/ExpandDims_1" + input: "capsule_layer_2/concat_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Softmax" + op: "Softmax" + input: "capsule_layer_2/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Reshape_1" + op: "Reshape" + input: "capsule_layer_2/Softmax" + input: "capsule_layer_2/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims_3/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims_3" + op: "ExpandDims" + input: "capsule_layer_2/Reshape_1" + input: "capsule_layer_2/ExpandDims_3/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Const_3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/split_1/split_dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2/split_1" + op: "Split" + input: "capsule_layer_2/split_1/split_dim" + input: "capsule_layer_2/ExpandDims_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2/concat_2/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "capsule_layer_2/concat_2" + op: "ConcatV2" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/split_1" + input: "capsule_layer_2/concat_2/axis" + attr { + key: "N" + value { + i: 16 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/mul" + op: "Mul" + input: "capsule_layer_2/concat_2" + input: "capsule_layer_2/map/TensorArrayStack/TensorArrayGatherV3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Sum" + op: "Sum" + input: "capsule_layer_2/mul" + input: "capsule_layer_2/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "capsule_layer_2/Square" + op: "Square" + input: "capsule_layer_2/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Sum_1/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2/Sum_1" + op: "Sum" + input: "capsule_layer_2/Square" + input: "capsule_layer_2/Sum_1/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } +} +node { + name: "capsule_layer_2/add/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "capsule_layer_2/add" + op: "Add" + input: "capsule_layer_2/add/x" + input: "capsule_layer_2/Sum_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/div" + op: "RealDiv" + input: "capsule_layer_2/Sum_1" + input: "capsule_layer_2/add" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/add_1/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.00000001169e-07 + } + } + } +} +node { + name: "capsule_layer_2/add_1" + op: "Add" + input: "capsule_layer_2/Sum_1" + input: "capsule_layer_2/add_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Const_4" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "capsule_layer_2/Const_5" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: inf + } + } + } +} +node { + name: "capsule_layer_2/clip_by_value/Minimum" + op: "Minimum" + input: "capsule_layer_2/add_1" + input: "capsule_layer_2/Const_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/clip_by_value" + op: "Maximum" + input: "capsule_layer_2/clip_by_value/Minimum" + input: "capsule_layer_2/Const_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Sqrt" + op: "Sqrt" + input: "capsule_layer_2/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/div_1" + op: "RealDiv" + input: "capsule_layer_2/div" + input: "capsule_layer_2/Sqrt" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/mul_1" + op: "Mul" + input: "capsule_layer_2/div_1" + input: "capsule_layer_2/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims_4/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims_4" + op: "ExpandDims" + input: "capsule_layer_2/mul_1" + input: "capsule_layer_2/ExpandDims_4/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/strided_slice/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/strided_slice/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "capsule_layer_2/strided_slice/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/strided_slice" + op: "StridedSlice" + input: "capsule_layer_2/Shape" + input: "capsule_layer_2/strided_slice/stack" + input: "capsule_layer_2/strided_slice/stack_1" + input: "capsule_layer_2/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2/Tile/multiples/0" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Tile/multiples/2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Tile/multiples/3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Tile/multiples" + op: "Pack" + input: "capsule_layer_2/Tile/multiples/0" + input: "capsule_layer_2/strided_slice" + input: "capsule_layer_2/Tile/multiples/2" + input: "capsule_layer_2/Tile/multiples/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "capsule_layer_2/Tile" + op: "Tile" + input: "capsule_layer_2/ExpandDims_4" + input: "capsule_layer_2/Tile/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/mul_2" + op: "Mul" + input: "capsule_layer_2/map/TensorArrayStack/TensorArrayGatherV3" + input: "capsule_layer_2/Tile" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Sum_2/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2/Sum_2" + op: "Sum" + input: "capsule_layer_2/mul_2" + input: "capsule_layer_2/Sum_2/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "capsule_layer_2/add_2" + op: "Add" + input: "capsule_layer_2/ExpandDims_1" + input: "capsule_layer_2/Sum_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Shape_3" + op: "Shape" + input: "capsule_layer_2/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "capsule_layer_2/Rank_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "capsule_layer_2/Shape_4" + op: "Shape" + input: "capsule_layer_2/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "capsule_layer_2/Sub_1/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Sub_1" + op: "Sub" + input: "capsule_layer_2/Rank_1" + input: "capsule_layer_2/Sub_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/Slice_1/begin" + op: "Pack" + input: "capsule_layer_2/Sub_1" + attr { + key: "N" + value { + i: 1 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "capsule_layer_2/Slice_1/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Slice_1" + op: "Slice" + input: "capsule_layer_2/Shape_4" + input: "capsule_layer_2/Slice_1/begin" + input: "capsule_layer_2/Slice_1/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/concat_3/values_0" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2/concat_3/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2/concat_3" + op: "ConcatV2" + input: "capsule_layer_2/concat_3/values_0" + input: "capsule_layer_2/Slice_1" + input: "capsule_layer_2/concat_3/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Reshape_2" + op: "Reshape" + input: "capsule_layer_2/add_2" + input: "capsule_layer_2/concat_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Softmax_1" + op: "Softmax" + input: "capsule_layer_2/Reshape_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Reshape_3" + op: "Reshape" + input: "capsule_layer_2/Softmax_1" + input: "capsule_layer_2/Shape_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims_5/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims_5" + op: "ExpandDims" + input: "capsule_layer_2/Reshape_3" + input: "capsule_layer_2/ExpandDims_5/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Const_6" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/split_2/split_dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2/split_2" + op: "Split" + input: "capsule_layer_2/split_2/split_dim" + input: "capsule_layer_2/ExpandDims_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2/concat_4/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "capsule_layer_2/concat_4" + op: "ConcatV2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/split_2" + input: "capsule_layer_2/concat_4/axis" + attr { + key: "N" + value { + i: 16 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/mul_3" + op: "Mul" + input: "capsule_layer_2/concat_4" + input: "capsule_layer_2/map/TensorArrayStack/TensorArrayGatherV3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Sum_3/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Sum_3" + op: "Sum" + input: "capsule_layer_2/mul_3" + input: "capsule_layer_2/Sum_3/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "capsule_layer_2/Square_1" + op: "Square" + input: "capsule_layer_2/Sum_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Sum_4/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2/Sum_4" + op: "Sum" + input: "capsule_layer_2/Square_1" + input: "capsule_layer_2/Sum_4/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } +} +node { + name: "capsule_layer_2/add_3/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "capsule_layer_2/add_3" + op: "Add" + input: "capsule_layer_2/add_3/x" + input: "capsule_layer_2/Sum_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/div_2" + op: "RealDiv" + input: "capsule_layer_2/Sum_4" + input: "capsule_layer_2/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/add_4/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.00000001169e-07 + } + } + } +} +node { + name: "capsule_layer_2/add_4" + op: "Add" + input: "capsule_layer_2/Sum_4" + input: "capsule_layer_2/add_4/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Const_7" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "capsule_layer_2/Const_8" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: inf + } + } + } +} +node { + name: "capsule_layer_2/clip_by_value_1/Minimum" + op: "Minimum" + input: "capsule_layer_2/add_4" + input: "capsule_layer_2/Const_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/clip_by_value_1" + op: "Maximum" + input: "capsule_layer_2/clip_by_value_1/Minimum" + input: "capsule_layer_2/Const_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Sqrt_1" + op: "Sqrt" + input: "capsule_layer_2/clip_by_value_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/div_3" + op: "RealDiv" + input: "capsule_layer_2/div_2" + input: "capsule_layer_2/Sqrt_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/mul_4" + op: "Mul" + input: "capsule_layer_2/div_3" + input: "capsule_layer_2/Sum_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims_6/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims_6" + op: "ExpandDims" + input: "capsule_layer_2/mul_4" + input: "capsule_layer_2/ExpandDims_6/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/strided_slice_1/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/strided_slice_1/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "capsule_layer_2/strided_slice_1/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/strided_slice_1" + op: "StridedSlice" + input: "capsule_layer_2/Shape" + input: "capsule_layer_2/strided_slice_1/stack" + input: "capsule_layer_2/strided_slice_1/stack_1" + input: "capsule_layer_2/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2/Tile_1/multiples/0" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Tile_1/multiples/2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Tile_1/multiples/3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Tile_1/multiples" + op: "Pack" + input: "capsule_layer_2/Tile_1/multiples/0" + input: "capsule_layer_2/strided_slice_1" + input: "capsule_layer_2/Tile_1/multiples/2" + input: "capsule_layer_2/Tile_1/multiples/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "capsule_layer_2/Tile_1" + op: "Tile" + input: "capsule_layer_2/ExpandDims_6" + input: "capsule_layer_2/Tile_1/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/mul_5" + op: "Mul" + input: "capsule_layer_2/map/TensorArrayStack/TensorArrayGatherV3" + input: "capsule_layer_2/Tile_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Sum_5/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2/Sum_5" + op: "Sum" + input: "capsule_layer_2/mul_5" + input: "capsule_layer_2/Sum_5/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "capsule_layer_2/add_5" + op: "Add" + input: "capsule_layer_2/add_2" + input: "capsule_layer_2/Sum_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Shape_5" + op: "Shape" + input: "capsule_layer_2/add_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "capsule_layer_2/Rank_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "capsule_layer_2/Shape_6" + op: "Shape" + input: "capsule_layer_2/add_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "capsule_layer_2/Sub_2/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Sub_2" + op: "Sub" + input: "capsule_layer_2/Rank_2" + input: "capsule_layer_2/Sub_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2/Slice_2/begin" + op: "Pack" + input: "capsule_layer_2/Sub_2" + attr { + key: "N" + value { + i: 1 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "capsule_layer_2/Slice_2/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Slice_2" + op: "Slice" + input: "capsule_layer_2/Shape_6" + input: "capsule_layer_2/Slice_2/begin" + input: "capsule_layer_2/Slice_2/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/concat_5/values_0" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2/concat_5/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2/concat_5" + op: "ConcatV2" + input: "capsule_layer_2/concat_5/values_0" + input: "capsule_layer_2/Slice_2" + input: "capsule_layer_2/concat_5/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Reshape_4" + op: "Reshape" + input: "capsule_layer_2/add_5" + input: "capsule_layer_2/concat_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Softmax_2" + op: "Softmax" + input: "capsule_layer_2/Reshape_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Reshape_5" + op: "Reshape" + input: "capsule_layer_2/Softmax_2" + input: "capsule_layer_2/Shape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims_7/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2/ExpandDims_7" + op: "ExpandDims" + input: "capsule_layer_2/Reshape_5" + input: "capsule_layer_2/ExpandDims_7/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Const_9" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/split_3/split_dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2/split_3" + op: "Split" + input: "capsule_layer_2/split_3/split_dim" + input: "capsule_layer_2/ExpandDims_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2/concat_6/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "capsule_layer_2/concat_6" + op: "ConcatV2" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/split_3" + input: "capsule_layer_2/concat_6/axis" + attr { + key: "N" + value { + i: 16 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/mul_6" + op: "Mul" + input: "capsule_layer_2/concat_6" + input: "capsule_layer_2/map/TensorArrayStack/TensorArrayGatherV3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Sum_6/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2/Sum_6" + op: "Sum" + input: "capsule_layer_2/mul_6" + input: "capsule_layer_2/Sum_6/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "capsule_layer_2/Square_2" + op: "Square" + input: "capsule_layer_2/Sum_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Sum_7/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2/Sum_7" + op: "Sum" + input: "capsule_layer_2/Square_2" + input: "capsule_layer_2/Sum_7/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } +} +node { + name: "capsule_layer_2/add_6/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "capsule_layer_2/add_6" + op: "Add" + input: "capsule_layer_2/add_6/x" + input: "capsule_layer_2/Sum_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/div_4" + op: "RealDiv" + input: "capsule_layer_2/Sum_7" + input: "capsule_layer_2/add_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/add_7/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.00000001169e-07 + } + } + } +} +node { + name: "capsule_layer_2/add_7" + op: "Add" + input: "capsule_layer_2/Sum_7" + input: "capsule_layer_2/add_7/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Const_10" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "capsule_layer_2/Const_11" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: inf + } + } + } +} +node { + name: "capsule_layer_2/clip_by_value_2/Minimum" + op: "Minimum" + input: "capsule_layer_2/add_7" + input: "capsule_layer_2/Const_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/clip_by_value_2" + op: "Maximum" + input: "capsule_layer_2/clip_by_value_2/Minimum" + input: "capsule_layer_2/Const_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/Sqrt_2" + op: "Sqrt" + input: "capsule_layer_2/clip_by_value_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/div_5" + op: "RealDiv" + input: "capsule_layer_2/div_4" + input: "capsule_layer_2/Sqrt_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2/mul_7" + op: "Mul" + input: "capsule_layer_2/div_5" + input: "capsule_layer_2/Sum_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "length_1/Square" + op: "Square" + input: "capsule_layer_2/mul_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "length_1/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "length_1/Sum" + op: "Sum" + input: "length_1/Square" + input: "length_1/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "length_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "length_1/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: inf + } + } + } +} +node { + name: "length_1/clip_by_value/Minimum" + op: "Minimum" + input: "length_1/Sum" + input: "length_1/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "length_1/clip_by_value" + op: "Maximum" + input: "length_1/clip_by_value/Minimum" + input: "length_1/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "length_1/Sqrt" + op: "Sqrt" + input: "length_1/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "mask_capsule_1/ExpandDims/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "mask_capsule_1/ExpandDims" + op: "ExpandDims" + input: "input_1" + input: "mask_capsule_1/ExpandDims/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "mask_capsule_1/mul" + op: "Mul" + input: "capsule_layer_2/mul_7" + input: "mask_capsule_1/ExpandDims" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "mask_capsule_1/Shape" + op: "Shape" + input: "mask_capsule_1/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "mask_capsule_1/strided_slice/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "mask_capsule_1/strided_slice/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "mask_capsule_1/strided_slice/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "mask_capsule_1/strided_slice" + op: "StridedSlice" + input: "mask_capsule_1/Shape" + input: "mask_capsule_1/strided_slice/stack" + input: "mask_capsule_1/strided_slice/stack_1" + input: "mask_capsule_1/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 1 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "mask_capsule_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "mask_capsule_1/Prod" + op: "Prod" + input: "mask_capsule_1/strided_slice" + input: "mask_capsule_1/Const" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "mask_capsule_1/stack/0" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "mask_capsule_1/stack" + op: "Pack" + input: "mask_capsule_1/stack/0" + input: "mask_capsule_1/Prod" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "mask_capsule_1/Reshape" + op: "Reshape" + input: "mask_capsule_1/mul" + input: "mask_capsule_1/stack" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "dense_1/truncated_normal/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\240\000\000\000\000\002\000\000" + } + } + } +} +node { + name: "dense_1/truncated_normal/mean" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "dense_1/truncated_normal/stddev" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0790569409728 + } + } + } +} +node { + name: "dense_1/truncated_normal/TruncatedNormal" + op: "TruncatedNormal" + input: "dense_1/truncated_normal/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 160 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 87654321 + } + } + attr { + key: "seed2" + value { + i: 1435693 + } + } +} +node { + name: "dense_1/truncated_normal/mul" + op: "Mul" + input: "dense_1/truncated_normal/TruncatedNormal" + input: "dense_1/truncated_normal/stddev" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 160 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "dense_1/truncated_normal" + op: "Add" + input: "dense_1/truncated_normal/mul" + input: "dense_1/truncated_normal/mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 160 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "dense_1/kernel" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 160 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 160 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dense_1/kernel/Assign" + op: "Assign" + input: "dense_1/kernel" + input: "dense_1/truncated_normal" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_1/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 160 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dense_1/kernel/read" + op: "Identity" + input: "dense_1/kernel" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_1/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 160 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "dense_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "dense_1/bias" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dense_1/bias/Assign" + op: "Assign" + input: "dense_1/bias" + input: "dense_1/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_1/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dense_1/bias/read" + op: "Identity" + input: "dense_1/bias" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_1/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "dense_1/MatMul" + op: "MatMul" + input: "mask_capsule_1/Reshape" + input: "dense_1/kernel/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "dense_1/BiasAdd" + op: "BiasAdd" + input: "dense_1/MatMul" + input: "dense_1/bias/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "activation_2/Relu" + op: "Relu" + input: "dense_1/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "dense_2/truncated_normal/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\000\002\000\000\000\004\000\000" + } + } + } +} +node { + name: "dense_2/truncated_normal/mean" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "dense_2/truncated_normal/stddev" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0441941730678 + } + } + } +} +node { + name: "dense_2/truncated_normal/TruncatedNormal" + op: "TruncatedNormal" + input: "dense_2/truncated_normal/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + dim { + size: 1024 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 87654321 + } + } + attr { + key: "seed2" + value { + i: 9637120 + } + } +} +node { + name: "dense_2/truncated_normal/mul" + op: "Mul" + input: "dense_2/truncated_normal/TruncatedNormal" + input: "dense_2/truncated_normal/stddev" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + dim { + size: 1024 + } + } + } + } + } +} +node { + name: "dense_2/truncated_normal" + op: "Add" + input: "dense_2/truncated_normal/mul" + input: "dense_2/truncated_normal/mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + dim { + size: 1024 + } + } + } + } + } +} +node { + name: "dense_2/kernel" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + dim { + size: 1024 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + dim { + size: 1024 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dense_2/kernel/Assign" + op: "Assign" + input: "dense_2/kernel" + input: "dense_2/truncated_normal" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_2/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + dim { + size: 1024 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dense_2/kernel/read" + op: "Identity" + input: "dense_2/kernel" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_2/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + dim { + size: 1024 + } + } + } + } + } +} +node { + name: "dense_2/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1024 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "dense_2/bias" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1024 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dense_2/bias/Assign" + op: "Assign" + input: "dense_2/bias" + input: "dense_2/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_2/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dense_2/bias/read" + op: "Identity" + input: "dense_2/bias" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_2/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + } + } + } + } +} +node { + name: "dense_2/MatMul" + op: "MatMul" + input: "activation_2/Relu" + input: "dense_2/kernel/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1024 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "dense_2/BiasAdd" + op: "BiasAdd" + input: "dense_2/MatMul" + input: "dense_2/bias/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1024 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "activation_3/Relu" + op: "Relu" + input: "dense_2/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1024 + } + } + } + } + } +} +node { + name: "dense_3/truncated_normal/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\000\004\000\000\020\003\000\000" + } + } + } +} +node { + name: "dense_3/truncated_normal/mean" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "dense_3/truncated_normal/stddev" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.03125 + } + } + } +} +node { + name: "dense_3/truncated_normal/TruncatedNormal" + op: "TruncatedNormal" + input: "dense_3/truncated_normal/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + dim { + size: 784 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 87654321 + } + } + attr { + key: "seed2" + value { + i: 2283979 + } + } +} +node { + name: "dense_3/truncated_normal/mul" + op: "Mul" + input: "dense_3/truncated_normal/TruncatedNormal" + input: "dense_3/truncated_normal/stddev" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + dim { + size: 784 + } + } + } + } + } +} +node { + name: "dense_3/truncated_normal" + op: "Add" + input: "dense_3/truncated_normal/mul" + input: "dense_3/truncated_normal/mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + dim { + size: 784 + } + } + } + } + } +} +node { + name: "dense_3/kernel" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + dim { + size: 784 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1024 + } + dim { + size: 784 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dense_3/kernel/Assign" + op: "Assign" + input: "dense_3/kernel" + input: "dense_3/truncated_normal" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_3/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + dim { + size: 784 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dense_3/kernel/read" + op: "Identity" + input: "dense_3/kernel" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_3/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + dim { + size: 784 + } + } + } + } + } +} +node { + name: "dense_3/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 784 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 784 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "dense_3/bias" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 784 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 784 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dense_3/bias/Assign" + op: "Assign" + input: "dense_3/bias" + input: "dense_3/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_3/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 784 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dense_3/bias/read" + op: "Identity" + input: "dense_3/bias" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_3/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 784 + } + } + } + } + } +} +node { + name: "dense_3/MatMul" + op: "MatMul" + input: "activation_3/Relu" + input: "dense_3/kernel/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 784 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "dense_3/BiasAdd" + op: "BiasAdd" + input: "dense_3/MatMul" + input: "dense_3/bias/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 784 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "activation_4/Sigmoid" + op: "Sigmoid" + input: "dense_3/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 784 + } + } + } + } + } +} +node { + name: "reshape_2/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\377\377\377\377\034\000\000\000\001\000\000\000\034\000\000\000" + } + } + } +} +node { + name: "reshape_2/Reshape" + op: "Reshape" + input: "activation_4/Sigmoid" + input: "reshape_2/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 28 + } + dim { + size: 1 + } + dim { + size: 28 + } + } + } + } + } +} +node { + name: "input_2_1" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 28 + } + dim { + size: 28 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 28 + } + dim { + size: 28 + } + dim { + size: 1 + } + } + } + } +} +node { + name: "input_1_1" + op: "Placeholder" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + } + } + } +} +node { + name: "conv2d_1_1/truncated_normal/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\t\000\000\000\t\000\000\000\001\000\000\000\000\001\000\000" + } + } + } +} +node { + name: "conv2d_1_1/truncated_normal/mean" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "conv2d_1_1/truncated_normal/stddev" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.111111111939 + } + } + } +} +node { + name: "conv2d_1_1/truncated_normal/TruncatedNormal" + op: "TruncatedNormal" + input: "conv2d_1_1/truncated_normal/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 1 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 87654321 + } + } + attr { + key: "seed2" + value { + i: 1659099 + } + } +} +node { + name: "conv2d_1_1/truncated_normal/mul" + op: "Mul" + input: "conv2d_1_1/truncated_normal/TruncatedNormal" + input: "conv2d_1_1/truncated_normal/stddev" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 1 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_1_1/truncated_normal" + op: "Add" + input: "conv2d_1_1/truncated_normal/mul" + input: "conv2d_1_1/truncated_normal/mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 1 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_1_1/kernel" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 1 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 1 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "conv2d_1_1/kernel/Assign" + op: "Assign" + input: "conv2d_1_1/kernel" + input: "conv2d_1_1/truncated_normal" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_1_1/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 1 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "conv2d_1_1/kernel/read" + op: "Identity" + input: "conv2d_1_1/kernel" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_1_1/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 1 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_1_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "conv2d_1_1/bias" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "conv2d_1_1/bias/Assign" + op: "Assign" + input: "conv2d_1_1/bias" + input: "conv2d_1_1/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_1_1/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "conv2d_1_1/bias/read" + op: "Identity" + input: "conv2d_1_1/bias" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_1_1/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_1_1/convolution/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "conv2d_1_1/convolution" + op: "Conv2D" + input: "input_2_1" + input: "conv2d_1_1/kernel/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 20 + } + dim { + size: 20 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "padding" + value { + s: "VALID" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "conv2d_1_1/BiasAdd" + op: "BiasAdd" + input: "conv2d_1_1/convolution" + input: "conv2d_1_1/bias/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 20 + } + dim { + size: 20 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "activation_1_1/Relu" + op: "Relu" + input: "conv2d_1_1/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 20 + } + dim { + size: 20 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_2_1/truncated_normal/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\t\000\000\000\t\000\000\000\000\001\000\000\000\001\000\000" + } + } + } +} +node { + name: "conv2d_2_1/truncated_normal/mean" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "conv2d_2_1/truncated_normal/stddev" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.00694444449618 + } + } + } +} +node { + name: "conv2d_2_1/truncated_normal/TruncatedNormal" + op: "TruncatedNormal" + input: "conv2d_2_1/truncated_normal/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 87654321 + } + } + attr { + key: "seed2" + value { + i: 4761021 + } + } +} +node { + name: "conv2d_2_1/truncated_normal/mul" + op: "Mul" + input: "conv2d_2_1/truncated_normal/TruncatedNormal" + input: "conv2d_2_1/truncated_normal/stddev" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_2_1/truncated_normal" + op: "Add" + input: "conv2d_2_1/truncated_normal/mul" + input: "conv2d_2_1/truncated_normal/mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_2_1/kernel" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "conv2d_2_1/kernel/Assign" + op: "Assign" + input: "conv2d_2_1/kernel" + input: "conv2d_2_1/truncated_normal" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_2_1/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "conv2d_2_1/kernel/read" + op: "Identity" + input: "conv2d_2_1/kernel" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_2_1/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 9 + } + dim { + size: 9 + } + dim { + size: 256 + } + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_2_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 256 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "conv2d_2_1/bias" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 256 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "conv2d_2_1/bias/Assign" + op: "Assign" + input: "conv2d_2_1/bias" + input: "conv2d_2_1/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_2_1/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "conv2d_2_1/bias/read" + op: "Identity" + input: "conv2d_2_1/bias" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@conv2d_2_1/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 256 + } + } + } + } + } +} +node { + name: "conv2d_2_1/convolution/dilation_rate" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\001\000\000\000\001\000\000\000" + } + } + } +} +node { + name: "conv2d_2_1/convolution" + op: "Conv2D" + input: "activation_1_1/Relu" + input: "conv2d_2_1/kernel/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 6 + } + dim { + size: 6 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "padding" + value { + s: "VALID" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 2 + i: 2 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "conv2d_2_1/BiasAdd" + op: "BiasAdd" + input: "conv2d_2_1/convolution" + input: "conv2d_2_1/bias/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 6 + } + dim { + size: 6 + } + dim { + size: 256 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "reshape_1_1/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\377\377\377\377\010\000\000\000\200\004\000\000" + } + } + } +} +node { + name: "reshape_1_1/Reshape" + op: "Reshape" + input: "conv2d_2_1/BiasAdd" + input: "reshape_1_1/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1152 + } + } + } + } + } +} +node { + name: "squash_1_1/Square" + op: "Square" + input: "reshape_1_1/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1152 + } + } + } + } + } +} +node { + name: "squash_1_1/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "squash_1_1/Sum" + op: "Sum" + input: "squash_1_1/Square" + input: "squash_1_1/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } +} +node { + name: "squash_1_1/add/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "squash_1_1/add" + op: "Add" + input: "squash_1_1/add/x" + input: "squash_1_1/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "squash_1_1/div" + op: "RealDiv" + input: "squash_1_1/Sum" + input: "squash_1_1/add" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "squash_1_1/add_1/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.00000001169e-07 + } + } + } +} +node { + name: "squash_1_1/add_1" + op: "Add" + input: "squash_1_1/Sum" + input: "squash_1_1/add_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "squash_1_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "squash_1_1/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: inf + } + } + } +} +node { + name: "squash_1_1/clip_by_value/Minimum" + op: "Minimum" + input: "squash_1_1/add_1" + input: "squash_1_1/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "squash_1_1/clip_by_value" + op: "Maximum" + input: "squash_1_1/clip_by_value/Minimum" + input: "squash_1_1/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "squash_1_1/Sqrt" + op: "Sqrt" + input: "squash_1_1/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "squash_1_1/div_1" + op: "RealDiv" + input: "squash_1_1/div" + input: "squash_1_1/Sqrt" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "squash_1_1/mul" + op: "Mul" + input: "squash_1_1/div_1" + input: "reshape_1_1/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1152 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/random_uniform/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\010\000\000\000\n\000\000\000\200\004\000\000\020\000\000\000" + } + } + } +} +node { + name: "capsule_layer_2_1/random_uniform/min" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: -1.0 + } + } + } +} +node { + name: "capsule_layer_2_1/random_uniform/max" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "capsule_layer_2_1/random_uniform/RandomUniform" + op: "RandomUniform" + input: "capsule_layer_2_1/random_uniform/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 87654321 + } + } + attr { + key: "seed2" + value { + i: 554449 + } + } +} +node { + name: "capsule_layer_2_1/random_uniform/sub" + op: "Sub" + input: "capsule_layer_2_1/random_uniform/max" + input: "capsule_layer_2_1/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/random_uniform/mul" + op: "Mul" + input: "capsule_layer_2_1/random_uniform/RandomUniform" + input: "capsule_layer_2_1/random_uniform/sub" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/random_uniform" + op: "Add" + input: "capsule_layer_2_1/random_uniform/mul" + input: "capsule_layer_2_1/random_uniform/min" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/W" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "capsule_layer_2_1/W/Assign" + op: "Assign" + input: "capsule_layer_2_1/W" + input: "capsule_layer_2_1/random_uniform" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/W" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "capsule_layer_2_1/W/read" + op: "Identity" + input: "capsule_layer_2_1/W" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/W" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "capsule_layer_2_1/b" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "capsule_layer_2_1/b/Assign" + op: "Assign" + input: "capsule_layer_2_1/b" + input: "capsule_layer_2_1/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/b" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "capsule_layer_2_1/b/read" + op: "Identity" + input: "capsule_layer_2_1/b" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/b" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "capsule_layer_2_1/c" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "capsule_layer_2_1/c/Assign" + op: "Assign" + input: "capsule_layer_2_1/c" + input: "capsule_layer_2_1/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/c" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "capsule_layer_2_1/c/read" + op: "Identity" + input: "capsule_layer_2_1/c" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/c" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims" + op: "ExpandDims" + input: "squash_1_1/mul" + input: "capsule_layer_2_1/ExpandDims/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + dim { + size: 1152 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Const_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/split/split_dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "capsule_layer_2_1/split" + op: "Split" + input: "capsule_layer_2_1/split/split_dim" + input: "capsule_layer_2_1/ExpandDims" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 1 + } + dim { + size: 1152 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2_1/concat/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 2 + } + } + } +} +node { + name: "capsule_layer_2_1/concat" + op: "ConcatV2" + input: "capsule_layer_2_1/split" + input: "capsule_layer_2_1/split" + input: "capsule_layer_2_1/split" + input: "capsule_layer_2_1/split" + input: "capsule_layer_2_1/split" + input: "capsule_layer_2_1/split" + input: "capsule_layer_2_1/split" + input: "capsule_layer_2_1/split" + input: "capsule_layer_2_1/split" + input: "capsule_layer_2_1/split" + input: "capsule_layer_2_1/concat/axis" + attr { + key: "N" + value { + i: 10 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/Shape" + op: "Shape" + input: "capsule_layer_2_1/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "capsule_layer_2_1/map/strided_slice/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2_1/map/strided_slice/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/map/strided_slice/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/map/strided_slice" + op: "StridedSlice" + input: "capsule_layer_2_1/map/Shape" + input: "capsule_layer_2_1/map/strided_slice/stack" + input: "capsule_layer_2_1/map/strided_slice/stack_1" + input: "capsule_layer_2_1/map/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArray" + op: "TensorArrayV3" + input: "capsule_layer_2_1/map/strided_slice" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + shape { + } + } + } + } + attr { + key: "clear_after_read" + value { + b: true + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "dynamic_size" + value { + b: false + } + } + attr { + key: "element_shape" + value { + shape { + unknown_rank: true + } + } + } + attr { + key: "tensor_array_name" + value { + s: "" + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArrayUnstack/Shape" + op: "Shape" + input: "capsule_layer_2_1/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArrayUnstack/strided_slice/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArrayUnstack/strided_slice/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArrayUnstack/strided_slice/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArrayUnstack/strided_slice" + op: "StridedSlice" + input: "capsule_layer_2_1/map/TensorArrayUnstack/Shape" + input: "capsule_layer_2_1/map/TensorArrayUnstack/strided_slice/stack" + input: "capsule_layer_2_1/map/TensorArrayUnstack/strided_slice/stack_1" + input: "capsule_layer_2_1/map/TensorArrayUnstack/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArrayUnstack/range/start" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArrayUnstack/range/delta" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArrayUnstack/range" + op: "Range" + input: "capsule_layer_2_1/map/TensorArrayUnstack/range/start" + input: "capsule_layer_2_1/map/TensorArrayUnstack/strided_slice" + input: "capsule_layer_2_1/map/TensorArrayUnstack/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArrayUnstack/TensorArrayScatter/TensorArrayScatterV3" + op: "TensorArrayScatterV3" + input: "capsule_layer_2_1/map/TensorArray" + input: "capsule_layer_2_1/map/TensorArrayUnstack/range" + input: "capsule_layer_2_1/concat" + input: "capsule_layer_2_1/map/TensorArray:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/concat" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArray_1" + op: "TensorArrayV3" + input: "capsule_layer_2_1/map/strided_slice" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + shape { + } + } + } + } + attr { + key: "clear_after_read" + value { + b: true + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "dynamic_size" + value { + b: false + } + } + attr { + key: "element_shape" + value { + shape { + unknown_rank: true + } + } + } + attr { + key: "tensor_array_name" + value { + s: "" + } + } +} +node { + name: "capsule_layer_2_1/map/while/Enter" + op: "Enter" + input: "capsule_layer_2_1/map/Const" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "frame_name" + value { + s: "capsule_layer_2_1/map/while/while_context" + } + } + attr { + key: "is_constant" + value { + b: false + } + } + attr { + key: "parallel_iterations" + value { + i: 10 + } + } +} +node { + name: "capsule_layer_2_1/map/while/Enter_1" + op: "Enter" + input: "capsule_layer_2_1/map/TensorArray_1:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "frame_name" + value { + s: "capsule_layer_2_1/map/while/while_context" + } + } + attr { + key: "is_constant" + value { + b: false + } + } + attr { + key: "parallel_iterations" + value { + i: 10 + } + } +} +node { + name: "capsule_layer_2_1/map/while/Merge" + op: "Merge" + input: "capsule_layer_2_1/map/while/Enter" + input: "capsule_layer_2_1/map/while/NextIteration" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/Merge_1" + op: "Merge" + input: "capsule_layer_2_1/map/while/Enter_1" + input: "capsule_layer_2_1/map/while/NextIteration_1" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/Less/Enter" + op: "Enter" + input: "capsule_layer_2_1/map/strided_slice" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "frame_name" + value { + s: "capsule_layer_2_1/map/while/while_context" + } + } + attr { + key: "is_constant" + value { + b: true + } + } + attr { + key: "parallel_iterations" + value { + i: 10 + } + } +} +node { + name: "capsule_layer_2_1/map/while/Less" + op: "Less" + input: "capsule_layer_2_1/map/while/Merge" + input: "capsule_layer_2_1/map/while/Less/Enter" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/LoopCond" + op: "LoopCond" + input: "capsule_layer_2_1/map/while/Less" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/Switch" + op: "Switch" + input: "capsule_layer_2_1/map/while/Merge" + input: "capsule_layer_2_1/map/while/LoopCond" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/map/while/Merge" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/Switch_1" + op: "Switch" + input: "capsule_layer_2_1/map/while/Merge_1" + input: "capsule_layer_2_1/map/while/LoopCond" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/map/while/Merge_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/Identity" + op: "Identity" + input: "capsule_layer_2_1/map/while/Switch:1" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/Identity_1" + op: "Identity" + input: "capsule_layer_2_1/map/while/Switch_1:1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/TensorArrayReadV3/Enter" + op: "Enter" + input: "capsule_layer_2_1/map/TensorArray" + attr { + key: "T" + value { + type: DT_RESOURCE + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "frame_name" + value { + s: "capsule_layer_2_1/map/while/while_context" + } + } + attr { + key: "is_constant" + value { + b: true + } + } + attr { + key: "parallel_iterations" + value { + i: 10 + } + } +} +node { + name: "capsule_layer_2_1/map/while/TensorArrayReadV3/Enter_1" + op: "Enter" + input: "capsule_layer_2_1/map/TensorArrayUnstack/TensorArrayScatter/TensorArrayScatterV3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "frame_name" + value { + s: "capsule_layer_2_1/map/while/while_context" + } + } + attr { + key: "is_constant" + value { + b: true + } + } + attr { + key: "parallel_iterations" + value { + i: 10 + } + } +} +node { + name: "capsule_layer_2_1/map/while/TensorArrayReadV3" + op: "TensorArrayReadV3" + input: "capsule_layer_2_1/map/while/TensorArrayReadV3/Enter" + input: "capsule_layer_2_1/map/while/Identity" + input: "capsule_layer_2_1/map/while/TensorArrayReadV3/Enter_1" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } +} +node { + name: "capsule_layer_2_1/map/while/Shape" + op: "Const" + input: "^capsule_layer_2_1/map/while/Identity" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\010\000\000\000\n\000\000\000\200\004\000\000" + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/concat/values_1" + op: "Const" + input: "^capsule_layer_2_1/map/while/Identity" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/concat/axis" + op: "Const" + input: "^capsule_layer_2_1/map/while/Identity" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/concat" + op: "ConcatV2" + input: "capsule_layer_2_1/map/while/Shape" + input: "capsule_layer_2_1/map/while/concat/values_1" + input: "capsule_layer_2_1/map/while/concat/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/Reshape" + op: "Reshape" + input: "capsule_layer_2_1/map/while/TensorArrayReadV3" + input: "capsule_layer_2_1/map/while/concat" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/MatMul/Enter" + op: "Enter" + input: "capsule_layer_2_1/W/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1152 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "frame_name" + value { + s: "capsule_layer_2_1/map/while/while_context" + } + } + attr { + key: "is_constant" + value { + b: true + } + } + attr { + key: "parallel_iterations" + value { + i: 10 + } + } +} +node { + name: "capsule_layer_2_1/map/while/MatMul" + op: "BatchMatMul" + input: "capsule_layer_2_1/map/while/Reshape" + input: "capsule_layer_2_1/map/while/MatMul/Enter" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "adj_x" + value { + b: true + } + } + attr { + key: "adj_y" + value { + b: false + } + } +} +node { + name: "capsule_layer_2_1/map/while/Squeeze" + op: "Squeeze" + input: "capsule_layer_2_1/map/while/MatMul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "squeeze_dims" + value { + list { + i: 2 + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/TensorArrayWrite/TensorArrayWriteV3/Enter" + op: "Enter" + input: "capsule_layer_2_1/map/TensorArray_1" + attr { + key: "T" + value { + type: DT_RESOURCE + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/map/while/Squeeze" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "frame_name" + value { + s: "capsule_layer_2_1/map/while/while_context" + } + } + attr { + key: "is_constant" + value { + b: true + } + } + attr { + key: "parallel_iterations" + value { + i: 10 + } + } +} +node { + name: "capsule_layer_2_1/map/while/TensorArrayWrite/TensorArrayWriteV3" + op: "TensorArrayWriteV3" + input: "capsule_layer_2_1/map/while/TensorArrayWrite/TensorArrayWriteV3/Enter" + input: "capsule_layer_2_1/map/while/Identity" + input: "capsule_layer_2_1/map/while/Squeeze" + input: "capsule_layer_2_1/map/while/Identity_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/map/while/Squeeze" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/add/y" + op: "Const" + input: "^capsule_layer_2_1/map/while/Identity" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/add" + op: "Add" + input: "capsule_layer_2_1/map/while/Identity" + input: "capsule_layer_2_1/map/while/add/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/NextIteration" + op: "NextIteration" + input: "capsule_layer_2_1/map/while/add" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/NextIteration_1" + op: "NextIteration" + input: "capsule_layer_2_1/map/while/TensorArrayWrite/TensorArrayWriteV3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/Exit" + op: "Exit" + input: "capsule_layer_2_1/map/while/Switch" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/while/Exit_1" + op: "Exit" + input: "capsule_layer_2_1/map/while/Switch_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArrayStack/TensorArraySizeV3" + op: "TensorArraySizeV3" + input: "capsule_layer_2_1/map/TensorArray_1" + input: "capsule_layer_2_1/map/while/Exit_1" + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/map/TensorArray_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArrayStack/range/start" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/map/TensorArray_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArrayStack/range/delta" + op: "Const" + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/map/TensorArray_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArrayStack/range" + op: "Range" + input: "capsule_layer_2_1/map/TensorArrayStack/range/start" + input: "capsule_layer_2_1/map/TensorArrayStack/TensorArraySizeV3" + input: "capsule_layer_2_1/map/TensorArrayStack/range/delta" + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/map/TensorArray_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/map/TensorArrayStack/TensorArrayGatherV3" + op: "TensorArrayGatherV3" + input: "capsule_layer_2_1/map/TensorArray_1" + input: "capsule_layer_2_1/map/TensorArrayStack/range" + input: "capsule_layer_2_1/map/while/Exit_1" + attr { + key: "_class" + value { + list { + s: "loc:@capsule_layer_2_1/map/TensorArray_1" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "element_shape" + value { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } +} +node { + name: "capsule_layer_2_1/Shape" + op: "Shape" + input: "capsule_layer_2_1/map/TensorArrayStack/TensorArrayGatherV3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims_1/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims_1" + op: "ExpandDims" + input: "capsule_layer_2_1/b/read" + input: "capsule_layer_2_1/ExpandDims_1/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims_2/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims_2" + op: "ExpandDims" + input: "capsule_layer_2_1/c/read" + input: "capsule_layer_2_1/ExpandDims_2/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Shape_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\010\000\000\000\n\000\000\000" + } + } + } +} +node { + name: "capsule_layer_2_1/Rank" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "capsule_layer_2_1/Shape_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 3 + } + } + tensor_content: "\001\000\000\000\010\000\000\000\n\000\000\000" + } + } + } +} +node { + name: "capsule_layer_2_1/Sub/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Sub" + op: "Sub" + input: "capsule_layer_2_1/Rank" + input: "capsule_layer_2_1/Sub/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/Slice/begin" + op: "Pack" + input: "capsule_layer_2_1/Sub" + attr { + key: "N" + value { + i: 1 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "capsule_layer_2_1/Slice/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Slice" + op: "Slice" + input: "capsule_layer_2_1/Shape_2" + input: "capsule_layer_2_1/Slice/begin" + input: "capsule_layer_2_1/Slice/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/concat_1/values_0" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2_1/concat_1/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2_1/concat_1" + op: "ConcatV2" + input: "capsule_layer_2_1/concat_1/values_0" + input: "capsule_layer_2_1/Slice" + input: "capsule_layer_2_1/concat_1/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Reshape" + op: "Reshape" + input: "capsule_layer_2_1/ExpandDims_1" + input: "capsule_layer_2_1/concat_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Softmax" + op: "Softmax" + input: "capsule_layer_2_1/Reshape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Reshape_1" + op: "Reshape" + input: "capsule_layer_2_1/Softmax" + input: "capsule_layer_2_1/Shape_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims_3/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims_3" + op: "ExpandDims" + input: "capsule_layer_2_1/Reshape_1" + input: "capsule_layer_2_1/ExpandDims_3/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Const_3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/split_1/split_dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2_1/split_1" + op: "Split" + input: "capsule_layer_2_1/split_1/split_dim" + input: "capsule_layer_2_1/ExpandDims_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2_1/concat_2/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "capsule_layer_2_1/concat_2" + op: "ConcatV2" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/split_1" + input: "capsule_layer_2_1/concat_2/axis" + attr { + key: "N" + value { + i: 16 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/mul" + op: "Mul" + input: "capsule_layer_2_1/concat_2" + input: "capsule_layer_2_1/map/TensorArrayStack/TensorArrayGatherV3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Sum" + op: "Sum" + input: "capsule_layer_2_1/mul" + input: "capsule_layer_2_1/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "capsule_layer_2_1/Square" + op: "Square" + input: "capsule_layer_2_1/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Sum_1/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2_1/Sum_1" + op: "Sum" + input: "capsule_layer_2_1/Square" + input: "capsule_layer_2_1/Sum_1/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } +} +node { + name: "capsule_layer_2_1/add/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "capsule_layer_2_1/add" + op: "Add" + input: "capsule_layer_2_1/add/x" + input: "capsule_layer_2_1/Sum_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/div" + op: "RealDiv" + input: "capsule_layer_2_1/Sum_1" + input: "capsule_layer_2_1/add" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/add_1/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.00000001169e-07 + } + } + } +} +node { + name: "capsule_layer_2_1/add_1" + op: "Add" + input: "capsule_layer_2_1/Sum_1" + input: "capsule_layer_2_1/add_1/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Const_4" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "capsule_layer_2_1/Const_5" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: inf + } + } + } +} +node { + name: "capsule_layer_2_1/clip_by_value/Minimum" + op: "Minimum" + input: "capsule_layer_2_1/add_1" + input: "capsule_layer_2_1/Const_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/clip_by_value" + op: "Maximum" + input: "capsule_layer_2_1/clip_by_value/Minimum" + input: "capsule_layer_2_1/Const_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Sqrt" + op: "Sqrt" + input: "capsule_layer_2_1/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/div_1" + op: "RealDiv" + input: "capsule_layer_2_1/div" + input: "capsule_layer_2_1/Sqrt" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/mul_1" + op: "Mul" + input: "capsule_layer_2_1/div_1" + input: "capsule_layer_2_1/Sum" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims_4/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims_4" + op: "ExpandDims" + input: "capsule_layer_2_1/mul_1" + input: "capsule_layer_2_1/ExpandDims_4/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/strided_slice/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/strided_slice/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "capsule_layer_2_1/strided_slice/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/strided_slice" + op: "StridedSlice" + input: "capsule_layer_2_1/Shape" + input: "capsule_layer_2_1/strided_slice/stack" + input: "capsule_layer_2_1/strided_slice/stack_1" + input: "capsule_layer_2_1/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2_1/Tile/multiples/0" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Tile/multiples/2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Tile/multiples/3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Tile/multiples" + op: "Pack" + input: "capsule_layer_2_1/Tile/multiples/0" + input: "capsule_layer_2_1/strided_slice" + input: "capsule_layer_2_1/Tile/multiples/2" + input: "capsule_layer_2_1/Tile/multiples/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "capsule_layer_2_1/Tile" + op: "Tile" + input: "capsule_layer_2_1/ExpandDims_4" + input: "capsule_layer_2_1/Tile/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/mul_2" + op: "Mul" + input: "capsule_layer_2_1/map/TensorArrayStack/TensorArrayGatherV3" + input: "capsule_layer_2_1/Tile" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Sum_2/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2_1/Sum_2" + op: "Sum" + input: "capsule_layer_2_1/mul_2" + input: "capsule_layer_2_1/Sum_2/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "capsule_layer_2_1/add_2" + op: "Add" + input: "capsule_layer_2_1/ExpandDims_1" + input: "capsule_layer_2_1/Sum_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Shape_3" + op: "Shape" + input: "capsule_layer_2_1/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "capsule_layer_2_1/Rank_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "capsule_layer_2_1/Shape_4" + op: "Shape" + input: "capsule_layer_2_1/add_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "capsule_layer_2_1/Sub_1/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Sub_1" + op: "Sub" + input: "capsule_layer_2_1/Rank_1" + input: "capsule_layer_2_1/Sub_1/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/Slice_1/begin" + op: "Pack" + input: "capsule_layer_2_1/Sub_1" + attr { + key: "N" + value { + i: 1 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "capsule_layer_2_1/Slice_1/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Slice_1" + op: "Slice" + input: "capsule_layer_2_1/Shape_4" + input: "capsule_layer_2_1/Slice_1/begin" + input: "capsule_layer_2_1/Slice_1/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/concat_3/values_0" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2_1/concat_3/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2_1/concat_3" + op: "ConcatV2" + input: "capsule_layer_2_1/concat_3/values_0" + input: "capsule_layer_2_1/Slice_1" + input: "capsule_layer_2_1/concat_3/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Reshape_2" + op: "Reshape" + input: "capsule_layer_2_1/add_2" + input: "capsule_layer_2_1/concat_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Softmax_1" + op: "Softmax" + input: "capsule_layer_2_1/Reshape_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Reshape_3" + op: "Reshape" + input: "capsule_layer_2_1/Softmax_1" + input: "capsule_layer_2_1/Shape_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims_5/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims_5" + op: "ExpandDims" + input: "capsule_layer_2_1/Reshape_3" + input: "capsule_layer_2_1/ExpandDims_5/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Const_6" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/split_2/split_dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2_1/split_2" + op: "Split" + input: "capsule_layer_2_1/split_2/split_dim" + input: "capsule_layer_2_1/ExpandDims_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2_1/concat_4/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "capsule_layer_2_1/concat_4" + op: "ConcatV2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/split_2" + input: "capsule_layer_2_1/concat_4/axis" + attr { + key: "N" + value { + i: 16 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/mul_3" + op: "Mul" + input: "capsule_layer_2_1/concat_4" + input: "capsule_layer_2_1/map/TensorArrayStack/TensorArrayGatherV3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Sum_3/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Sum_3" + op: "Sum" + input: "capsule_layer_2_1/mul_3" + input: "capsule_layer_2_1/Sum_3/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "capsule_layer_2_1/Square_1" + op: "Square" + input: "capsule_layer_2_1/Sum_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Sum_4/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2_1/Sum_4" + op: "Sum" + input: "capsule_layer_2_1/Square_1" + input: "capsule_layer_2_1/Sum_4/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } +} +node { + name: "capsule_layer_2_1/add_3/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "capsule_layer_2_1/add_3" + op: "Add" + input: "capsule_layer_2_1/add_3/x" + input: "capsule_layer_2_1/Sum_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/div_2" + op: "RealDiv" + input: "capsule_layer_2_1/Sum_4" + input: "capsule_layer_2_1/add_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/add_4/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.00000001169e-07 + } + } + } +} +node { + name: "capsule_layer_2_1/add_4" + op: "Add" + input: "capsule_layer_2_1/Sum_4" + input: "capsule_layer_2_1/add_4/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Const_7" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "capsule_layer_2_1/Const_8" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: inf + } + } + } +} +node { + name: "capsule_layer_2_1/clip_by_value_1/Minimum" + op: "Minimum" + input: "capsule_layer_2_1/add_4" + input: "capsule_layer_2_1/Const_8" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/clip_by_value_1" + op: "Maximum" + input: "capsule_layer_2_1/clip_by_value_1/Minimum" + input: "capsule_layer_2_1/Const_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Sqrt_1" + op: "Sqrt" + input: "capsule_layer_2_1/clip_by_value_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/div_3" + op: "RealDiv" + input: "capsule_layer_2_1/div_2" + input: "capsule_layer_2_1/Sqrt_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/mul_4" + op: "Mul" + input: "capsule_layer_2_1/div_3" + input: "capsule_layer_2_1/Sum_3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims_6/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims_6" + op: "ExpandDims" + input: "capsule_layer_2_1/mul_4" + input: "capsule_layer_2_1/ExpandDims_6/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/strided_slice_1/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/strided_slice_1/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 2 + } + } + } +} +node { + name: "capsule_layer_2_1/strided_slice_1/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/strided_slice_1" + op: "StridedSlice" + input: "capsule_layer_2_1/Shape" + input: "capsule_layer_2_1/strided_slice_1/stack" + input: "capsule_layer_2_1/strided_slice_1/stack_1" + input: "capsule_layer_2_1/strided_slice_1/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 0 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2_1/Tile_1/multiples/0" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Tile_1/multiples/2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Tile_1/multiples/3" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Tile_1/multiples" + op: "Pack" + input: "capsule_layer_2_1/Tile_1/multiples/0" + input: "capsule_layer_2_1/strided_slice_1" + input: "capsule_layer_2_1/Tile_1/multiples/2" + input: "capsule_layer_2_1/Tile_1/multiples/3" + attr { + key: "N" + value { + i: 4 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "capsule_layer_2_1/Tile_1" + op: "Tile" + input: "capsule_layer_2_1/ExpandDims_6" + input: "capsule_layer_2_1/Tile_1/multiples" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tmultiples" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/mul_5" + op: "Mul" + input: "capsule_layer_2_1/map/TensorArrayStack/TensorArrayGatherV3" + input: "capsule_layer_2_1/Tile_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Sum_5/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2_1/Sum_5" + op: "Sum" + input: "capsule_layer_2_1/mul_5" + input: "capsule_layer_2_1/Sum_5/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "capsule_layer_2_1/add_5" + op: "Add" + input: "capsule_layer_2_1/add_2" + input: "capsule_layer_2_1/Sum_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Shape_5" + op: "Shape" + input: "capsule_layer_2_1/add_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "capsule_layer_2_1/Rank_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "capsule_layer_2_1/Shape_6" + op: "Shape" + input: "capsule_layer_2_1/add_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "capsule_layer_2_1/Sub_2/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Sub_2" + op: "Sub" + input: "capsule_layer_2_1/Rank_2" + input: "capsule_layer_2_1/Sub_2/y" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } +} +node { + name: "capsule_layer_2_1/Slice_2/begin" + op: "Pack" + input: "capsule_layer_2_1/Sub_2" + attr { + key: "N" + value { + i: 1 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "capsule_layer_2_1/Slice_2/size" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Slice_2" + op: "Slice" + input: "capsule_layer_2_1/Shape_6" + input: "capsule_layer_2_1/Slice_2/begin" + input: "capsule_layer_2_1/Slice_2/size" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/concat_5/values_0" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2_1/concat_5/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 0 + } + } + } +} +node { + name: "capsule_layer_2_1/concat_5" + op: "ConcatV2" + input: "capsule_layer_2_1/concat_5/values_0" + input: "capsule_layer_2_1/Slice_2" + input: "capsule_layer_2_1/concat_5/axis" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Reshape_4" + op: "Reshape" + input: "capsule_layer_2_1/add_5" + input: "capsule_layer_2_1/concat_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Softmax_2" + op: "Softmax" + input: "capsule_layer_2_1/Reshape_4" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Reshape_5" + op: "Reshape" + input: "capsule_layer_2_1/Softmax_2" + input: "capsule_layer_2_1/Shape_5" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims_7/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2_1/ExpandDims_7" + op: "ExpandDims" + input: "capsule_layer_2_1/Reshape_5" + input: "capsule_layer_2_1/ExpandDims_7/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Const_9" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/split_3/split_dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2_1/split_3" + op: "Split" + input: "capsule_layer_2_1/split_3/split_dim" + input: "capsule_layer_2_1/ExpandDims_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "num_split" + value { + i: 1 + } + } +} +node { + name: "capsule_layer_2_1/concat_6/axis" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 3 + } + } + } +} +node { + name: "capsule_layer_2_1/concat_6" + op: "ConcatV2" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/split_3" + input: "capsule_layer_2_1/concat_6/axis" + attr { + key: "N" + value { + i: 16 + } + } + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/mul_6" + op: "Mul" + input: "capsule_layer_2_1/concat_6" + input: "capsule_layer_2_1/map/TensorArrayStack/TensorArrayGatherV3" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 8 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Sum_6/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: 1 + } + } + } +} +node { + name: "capsule_layer_2_1/Sum_6" + op: "Sum" + input: "capsule_layer_2_1/mul_6" + input: "capsule_layer_2_1/Sum_6/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "capsule_layer_2_1/Square_2" + op: "Square" + input: "capsule_layer_2_1/Sum_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Sum_7/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "capsule_layer_2_1/Sum_7" + op: "Sum" + input: "capsule_layer_2_1/Square_2" + input: "capsule_layer_2_1/Sum_7/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: true + } + } +} +node { + name: "capsule_layer_2_1/add_6/x" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.0 + } + } + } +} +node { + name: "capsule_layer_2_1/add_6" + op: "Add" + input: "capsule_layer_2_1/add_6/x" + input: "capsule_layer_2_1/Sum_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/div_4" + op: "RealDiv" + input: "capsule_layer_2_1/Sum_7" + input: "capsule_layer_2_1/add_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/add_7/y" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 1.00000001169e-07 + } + } + } +} +node { + name: "capsule_layer_2_1/add_7" + op: "Add" + input: "capsule_layer_2_1/Sum_7" + input: "capsule_layer_2_1/add_7/y" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Const_10" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "capsule_layer_2_1/Const_11" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: inf + } + } + } +} +node { + name: "capsule_layer_2_1/clip_by_value_2/Minimum" + op: "Minimum" + input: "capsule_layer_2_1/add_7" + input: "capsule_layer_2_1/Const_11" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/clip_by_value_2" + op: "Maximum" + input: "capsule_layer_2_1/clip_by_value_2/Minimum" + input: "capsule_layer_2_1/Const_10" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/Sqrt_2" + op: "Sqrt" + input: "capsule_layer_2_1/clip_by_value_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/div_5" + op: "RealDiv" + input: "capsule_layer_2_1/div_4" + input: "capsule_layer_2_1/Sqrt_2" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "capsule_layer_2_1/mul_7" + op: "Mul" + input: "capsule_layer_2_1/div_5" + input: "capsule_layer_2_1/Sum_6" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "mask_capsule_1_1/ExpandDims/dim" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "mask_capsule_1_1/ExpandDims" + op: "ExpandDims" + input: "input_1_1" + input: "mask_capsule_1_1/ExpandDims/dim" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tdim" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 1 + } + } + } + } + } +} +node { + name: "mask_capsule_1_1/mul" + op: "Mul" + input: "capsule_layer_2_1/mul_7" + input: "mask_capsule_1_1/ExpandDims" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "mask_capsule_1_1/Shape" + op: "Shape" + input: "mask_capsule_1_1/mul" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 3 + } + } + } + } + } + attr { + key: "out_type" + value { + type: DT_INT32 + } + } +} +node { + name: "mask_capsule_1_1/strided_slice/stack" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "mask_capsule_1_1/strided_slice/stack_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "mask_capsule_1_1/strided_slice/stack_2" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 1 + } + } + } +} +node { + name: "mask_capsule_1_1/strided_slice" + op: "StridedSlice" + input: "mask_capsule_1_1/Shape" + input: "mask_capsule_1_1/strided_slice/stack" + input: "mask_capsule_1_1/strided_slice/stack_1" + input: "mask_capsule_1_1/strided_slice/stack_2" + attr { + key: "Index" + value { + type: DT_INT32 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "begin_mask" + value { + i: 0 + } + } + attr { + key: "ellipsis_mask" + value { + i: 0 + } + } + attr { + key: "end_mask" + value { + i: 1 + } + } + attr { + key: "new_axis_mask" + value { + i: 0 + } + } + attr { + key: "shrink_axis_mask" + value { + i: 0 + } + } +} +node { + name: "mask_capsule_1_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 1 + } + } + int_val: 0 + } + } + } +} +node { + name: "mask_capsule_1_1/Prod" + op: "Prod" + input: "mask_capsule_1_1/strided_slice" + input: "mask_capsule_1_1/Const" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "mask_capsule_1_1/stack/0" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "mask_capsule_1_1/stack" + op: "Pack" + input: "mask_capsule_1_1/stack/0" + input: "mask_capsule_1_1/Prod" + attr { + key: "N" + value { + i: 2 + } + } + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "axis" + value { + i: 0 + } + } +} +node { + name: "mask_capsule_1_1/Reshape" + op: "Reshape" + input: "mask_capsule_1_1/mul" + input: "mask_capsule_1_1/stack" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: -1 + } + } + } + } + } +} +node { + name: "dense_1_1/truncated_normal/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\240\000\000\000\000\002\000\000" + } + } + } +} +node { + name: "dense_1_1/truncated_normal/mean" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "dense_1_1/truncated_normal/stddev" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0790569409728 + } + } + } +} +node { + name: "dense_1_1/truncated_normal/TruncatedNormal" + op: "TruncatedNormal" + input: "dense_1_1/truncated_normal/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 160 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 87654321 + } + } + attr { + key: "seed2" + value { + i: 187633 + } + } +} +node { + name: "dense_1_1/truncated_normal/mul" + op: "Mul" + input: "dense_1_1/truncated_normal/TruncatedNormal" + input: "dense_1_1/truncated_normal/stddev" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 160 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "dense_1_1/truncated_normal" + op: "Add" + input: "dense_1_1/truncated_normal/mul" + input: "dense_1_1/truncated_normal/mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 160 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "dense_1_1/kernel" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 160 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 160 + } + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dense_1_1/kernel/Assign" + op: "Assign" + input: "dense_1_1/kernel" + input: "dense_1_1/truncated_normal" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_1_1/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 160 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dense_1_1/kernel/read" + op: "Identity" + input: "dense_1_1/kernel" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_1_1/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 160 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "dense_1_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 512 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "dense_1_1/bias" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dense_1_1/bias/Assign" + op: "Assign" + input: "dense_1_1/bias" + input: "dense_1_1/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_1_1/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dense_1_1/bias/read" + op: "Identity" + input: "dense_1_1/bias" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_1_1/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + } + } + } + } +} +node { + name: "dense_1_1/MatMul" + op: "MatMul" + input: "mask_capsule_1_1/Reshape" + input: "dense_1_1/kernel/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "dense_1_1/BiasAdd" + op: "BiasAdd" + input: "dense_1_1/MatMul" + input: "dense_1_1/bias/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 512 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "activation_2_1/Relu" + op: "Relu" + input: "dense_1_1/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 512 + } + } + } + } + } +} +node { + name: "dense_2_1/truncated_normal/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\000\002\000\000\000\004\000\000" + } + } + } +} +node { + name: "dense_2_1/truncated_normal/mean" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "dense_2_1/truncated_normal/stddev" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0441941730678 + } + } + } +} +node { + name: "dense_2_1/truncated_normal/TruncatedNormal" + op: "TruncatedNormal" + input: "dense_2_1/truncated_normal/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + dim { + size: 1024 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 87654321 + } + } + attr { + key: "seed2" + value { + i: 6778894 + } + } +} +node { + name: "dense_2_1/truncated_normal/mul" + op: "Mul" + input: "dense_2_1/truncated_normal/TruncatedNormal" + input: "dense_2_1/truncated_normal/stddev" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + dim { + size: 1024 + } + } + } + } + } +} +node { + name: "dense_2_1/truncated_normal" + op: "Add" + input: "dense_2_1/truncated_normal/mul" + input: "dense_2_1/truncated_normal/mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + dim { + size: 1024 + } + } + } + } + } +} +node { + name: "dense_2_1/kernel" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + dim { + size: 1024 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 512 + } + dim { + size: 1024 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dense_2_1/kernel/Assign" + op: "Assign" + input: "dense_2_1/kernel" + input: "dense_2_1/truncated_normal" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_2_1/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + dim { + size: 1024 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dense_2_1/kernel/read" + op: "Identity" + input: "dense_2_1/kernel" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_2_1/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 512 + } + dim { + size: 1024 + } + } + } + } + } +} +node { + name: "dense_2_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1024 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "dense_2_1/bias" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1024 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dense_2_1/bias/Assign" + op: "Assign" + input: "dense_2_1/bias" + input: "dense_2_1/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_2_1/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dense_2_1/bias/read" + op: "Identity" + input: "dense_2_1/bias" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_2_1/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + } + } + } + } +} +node { + name: "dense_2_1/MatMul" + op: "MatMul" + input: "activation_2_1/Relu" + input: "dense_2_1/kernel/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1024 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "dense_2_1/BiasAdd" + op: "BiasAdd" + input: "dense_2_1/MatMul" + input: "dense_2_1/bias/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1024 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "activation_3_1/Relu" + op: "Relu" + input: "dense_2_1/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 1024 + } + } + } + } + } +} +node { + name: "dense_3_1/truncated_normal/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 2 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 2 + } + } + tensor_content: "\000\004\000\000\020\003\000\000" + } + } + } +} +node { + name: "dense_3_1/truncated_normal/mean" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "dense_3_1/truncated_normal/stddev" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.03125 + } + } + } +} +node { + name: "dense_3_1/truncated_normal/TruncatedNormal" + op: "TruncatedNormal" + input: "dense_3_1/truncated_normal/shape" + attr { + key: "T" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + dim { + size: 784 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "seed" + value { + i: 87654321 + } + } + attr { + key: "seed2" + value { + i: 5323536 + } + } +} +node { + name: "dense_3_1/truncated_normal/mul" + op: "Mul" + input: "dense_3_1/truncated_normal/TruncatedNormal" + input: "dense_3_1/truncated_normal/stddev" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + dim { + size: 784 + } + } + } + } + } +} +node { + name: "dense_3_1/truncated_normal" + op: "Add" + input: "dense_3_1/truncated_normal/mul" + input: "dense_3_1/truncated_normal/mean" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + dim { + size: 784 + } + } + } + } + } +} +node { + name: "dense_3_1/kernel" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + dim { + size: 784 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1024 + } + dim { + size: 784 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dense_3_1/kernel/Assign" + op: "Assign" + input: "dense_3_1/kernel" + input: "dense_3_1/truncated_normal" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_3_1/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + dim { + size: 784 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dense_3_1/kernel/read" + op: "Identity" + input: "dense_3_1/kernel" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_3_1/kernel" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 1024 + } + dim { + size: 784 + } + } + } + } + } +} +node { + name: "dense_3_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 784 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 784 + } + } + float_val: 0.0 + } + } + } +} +node { + name: "dense_3_1/bias" + op: "VariableV2" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 784 + } + } + } + } + } + attr { + key: "container" + value { + s: "" + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 784 + } + } + } + } + attr { + key: "shared_name" + value { + s: "" + } + } +} +node { + name: "dense_3_1/bias/Assign" + op: "Assign" + input: "dense_3_1/bias" + input: "dense_3_1/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_3_1/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 784 + } + } + } + } + } + attr { + key: "use_locking" + value { + b: true + } + } + attr { + key: "validate_shape" + value { + b: true + } + } +} +node { + name: "dense_3_1/bias/read" + op: "Identity" + input: "dense_3_1/bias" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_class" + value { + list { + s: "loc:@dense_3_1/bias" + } + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 784 + } + } + } + } + } +} +node { + name: "dense_3_1/MatMul" + op: "MatMul" + input: "activation_3_1/Relu" + input: "dense_3_1/kernel/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 784 + } + } + } + } + } + attr { + key: "transpose_a" + value { + b: false + } + } + attr { + key: "transpose_b" + value { + b: false + } + } +} +node { + name: "dense_3_1/BiasAdd" + op: "BiasAdd" + input: "dense_3_1/MatMul" + input: "dense_3_1/bias/read" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 784 + } + } + } + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } +} +node { + name: "activation_4_1/Sigmoid" + op: "Sigmoid" + input: "dense_3_1/BiasAdd" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 784 + } + } + } + } + } +} +node { + name: "length_1_1/Square" + op: "Square" + input: "capsule_layer_2_1/mul_7" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + dim { + size: 16 + } + } + } + } + } +} +node { + name: "length_1_1/Sum/reduction_indices" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + } + int_val: -1 + } + } + } +} +node { + name: "length_1_1/Sum" + op: "Sum" + input: "length_1_1/Square" + input: "length_1_1/Sum/reduction_indices" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tidx" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + } + } + } + } + attr { + key: "keep_dims" + value { + b: false + } + } +} +node { + name: "length_1_1/Const" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: 0.0 + } + } + } +} +node { + name: "length_1_1/Const_1" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + } + } + } + } + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + } + float_val: inf + } + } + } +} +node { + name: "length_1_1/clip_by_value/Minimum" + op: "Minimum" + input: "length_1_1/Sum" + input: "length_1_1/Const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "length_1_1/clip_by_value" + op: "Maximum" + input: "length_1_1/clip_by_value/Minimum" + input: "length_1_1/Const" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "length_1_1/Sqrt" + op: "Sqrt" + input: "length_1_1/clip_by_value" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 10 + } + } + } + } + } +} +node { + name: "reshape_2_1/Reshape/shape" + op: "Const" + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: 4 + } + } + } + } + } + attr { + key: "dtype" + value { + type: DT_INT32 + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_INT32 + tensor_shape { + dim { + size: 4 + } + } + tensor_content: "\377\377\377\377\034\000\000\000\001\000\000\000\034\000\000\000" + } + } + } +} +node { + name: "reshape_2_1/Reshape" + op: "Reshape" + input: "activation_4_1/Sigmoid" + input: "reshape_2_1/Reshape/shape" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "Tshape" + value { + type: DT_INT32 + } + } + attr { + key: "_output_shapes" + value { + list { + shape { + dim { + size: -1 + } + dim { + size: 28 + } + dim { + size: 1 + } + dim { + size: 28 + } + } + } + } + } +} +node { + name: "init" + op: "NoOp" + input: "^conv2d_1/kernel/Assign" + input: "^conv2d_1/bias/Assign" + input: "^conv2d_2/kernel/Assign" + input: "^conv2d_2/bias/Assign" + input: "^capsule_layer_2/W/Assign" + input: "^capsule_layer_2/b/Assign" + input: "^capsule_layer_2/c/Assign" + input: "^dense_1/kernel/Assign" + input: "^dense_1/bias/Assign" + input: "^dense_2/kernel/Assign" + input: "^dense_2/bias/Assign" + input: "^dense_3/kernel/Assign" + input: "^dense_3/bias/Assign" + input: "^conv2d_1_1/kernel/Assign" + input: "^conv2d_1_1/bias/Assign" + input: "^conv2d_2_1/kernel/Assign" + input: "^conv2d_2_1/bias/Assign" + input: "^capsule_layer_2_1/W/Assign" + input: "^capsule_layer_2_1/b/Assign" + input: "^capsule_layer_2_1/c/Assign" + input: "^dense_1_1/kernel/Assign" + input: "^dense_1_1/bias/Assign" + input: "^dense_2_1/kernel/Assign" + input: "^dense_2_1/bias/Assign" + input: "^dense_3_1/kernel/Assign" + input: "^dense_3_1/bias/Assign" +} +versions { + producer: 24 +} diff --git a/tensorflow_app/views/import_graphdef.py b/tensorflow_app/views/import_graphdef.py index 984d495ae..59b12f286 100644 --- a/tensorflow_app/views/import_graphdef.py +++ b/tensorflow_app/views/import_graphdef.py @@ -15,14 +15,16 @@ 'DepthwiseConv2dNative': 'DepthwiseConv', 'MatMul': 'InnerProduct', 'Prod': 'InnerProduct', 'LRN': 'LRN', 'Concat': 'Concat', 'AvgPool': 'Pooling', 'Reshape': 'Flatten', 'FusedBatchNorm': 'BatchNorm', - 'Conv2DBackpropInput': 'Deconvolution'} + 'Conv2DBackpropInput': 'Deconvolution', 'CapsuleLayer': 'CapsuleLayer', + 'MaskCapsule': 'MaskCapsule', 'Length': 'Length', 'Squash': 'Squash'} activation_map = {'Sigmoid': 'Sigmoid', 'Softplus': 'Softplus', 'Softsign': 'Softsign', 'Elu': 'ELU', 'LeakyRelu': 'ReLU', 'Softmax': 'Softmax', 'Relu': 'ReLU', 'Tanh': 'TanH', 'SELU': 'SELU'} name_map = {'flatten': 'Flatten', 'dropout': 'Dropout', 'lrn': 'LRN', 'concatenate': 'Concat', - 'batch': 'BatchNorm', 'add': 'Eltwise', 'mul': 'Eltwise'} + 'batch': 'BatchNorm', 'add': 'Eltwise', 'mul': 'Eltwise', 'capsule_layer': 'CapsuleLayer', + 'mask_capsule': 'MaskCapsule', 'length': 'Length', 'squash': 'Squash'} initializer_map = {'random_uniform': 'RandomUniform', 'random_normal': 'RandomNormal', 'Const': 'Constant', 'zeros': 'Zeros', 'ones': 'Ones', @@ -514,6 +516,24 @@ def import_graph_def(request): layer['params']['seed'] = node.get_attr('seed') if ('training' in node.node_def.attr): layer['params']['trainable'] = node.get_attr('training') + + elif layer['type'][0] == 'CapsuleLayer': + if ('num_capsule' in node.node_def.attr): + layer['params']['num_capsule'] = node.get_attr('num_capsule') + if ('dim_capsule' in node.node_def.attr): + layer['params']['dim_capsule'] = node.get_attr('dim_capsule') + if ('num_routing' in node.node_def.attr): + layer['params']['num_routing'] = node.get_attr('num_routing') + + elif layer['type'][0] == 'Squash': + if ('axis' in node.node_def.attr): + layer['params']['axis'] = node.get_attr('axis') + + elif layer['type'][0] == 'MaskCapsule': + pass + + elif layer['type'][0] == 'Length': + pass net = {} batch_norms = [] for key in d.keys(): diff --git a/tensorflow_app/views/json2pbtxt.py b/tensorflow_app/views/json2pbtxt.py index 7afdf596b..1cdb2f565 100644 --- a/tensorflow_app/views/json2pbtxt.py +++ b/tensorflow_app/views/json2pbtxt.py @@ -28,7 +28,14 @@ json_str = json_str.strip("'<>() ").replace('\'', '\"') lrn = imp.load_source('LRN', BASE_DIR + '/keras_app/custom_layers/lrn.py') -model = model_from_json(json_str, {'LRN': lrn.LRN}) +capsule_layer = imp.load_source('CapsuleLayer', BASE_DIR + '/keras_app/custom_layers/capsule_layer.py') +mask_capsule = imp.load_source('MaskCapsule', BASE_DIR + '/keras_app/custom_layers/mask_capsule.py') +length = imp.load_source('Length', BASE_DIR + '/keras_app/custom_layers/length.py') +squash = imp.load_source('Squash', BASE_DIR + '/keras_app/custom_layers/squash.py') +model = model_from_json(json_str, {'LRN': lrn.LRN, 'CapsuleLayer': capsule_layer.CapsuleLayer, + 'Length': length.Length, + 'MaskCapsule': mask_capsule.MaskCapsule, + 'Squash': squash.Squash}) sess = K.get_session() tf.train.write_graph(sess.graph.as_graph_def(add_shapes=True), output_fld, diff --git a/tests/unit/tensorflow_app/test_views.py b/tests/unit/tensorflow_app/test_views.py index 209fdeb27..0674af86c 100644 --- a/tests/unit/tensorflow_app/test_views.py +++ b/tests/unit/tensorflow_app/test_views.py @@ -125,3 +125,26 @@ def test_custom_lrn_tf_import(self): response = self.client.post(reverse('tf-import'), {'file': model_file}) response = json.loads(response.content) self.assertEqual(response['result'], 'success') + + +class CapsuleLayersImportTest(unittest.TestCase): + def setUp(self): + self.client = Client() + + def test_tf_export(self): + model_file = open(os.path.join(settings.BASE_DIR, 'example/keras', + 'Capsnet.json'), 'r') + response = self.client.post(reverse('keras-import'), {'file': model_file}) + response = json.loads(response.content) + net = get_shapes(response['net']) + response = self.client.post(reverse('tf-export'), {'net': json.dumps(net), + 'net_name': ''}) + response = json.loads(response.content) + self.assertEqual(response['result'], 'success') + + def test_custom_CapsuleLayers_tf_import(self): + model_file = open(os.path.join(settings.BASE_DIR, 'example/tensorflow', + 'Capsulelayers.pbtxt'), 'r') + response = self.client.post(reverse('tf-import'), {'file': model_file}) + response = json.loads(response.content) + self.assertEqual(response['result'], 'success') From cf109e7cd06c12db120d9b8ce0546cd4639f8d94 Mon Sep 17 00:00:00 2001 From: namish800 Date: Fri, 9 Nov 2018 20:12:29 +0530 Subject: [PATCH 08/12] Added parameter calculation logic for CapsuleLayer --- ide/static/js/content.js | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/ide/static/js/content.js b/ide/static/js/content.js index 9a0c92d4c..02f1e15c4 100644 --- a/ide/static/js/content.js +++ b/ide/static/js/content.js @@ -558,6 +558,7 @@ class Content extends React.Component { var filter_layers = ["Convolution", "Deconvolution"]; var fc_layers = ["InnerProduct", "Embed", "Recurrent", "LSTM"]; + var capsule_layer = ["CapsuleLayer"]; if(filter_layers.includes(layer.info.type)) { // if layer is Conv or DeConv calculating total parameter of the layer using: @@ -573,6 +574,16 @@ class Content extends React.Component { weight_params = layer.shape['input'][0] * kernel_params * layer.params['num_output'][0]; bias_params += layer.params['num_output'][0]; } + else if(capsule_layer.includes(layer.info.type)) { + // if layer is CapsuleLayer calculating total parameters of the layer using: + // Weight parameters: In_caps * Out_caps * In_dim * Out_dim + // Bias parameters: 2 * In_caps * Out_caps + var w_shape = [layer.shape['input'][1], layer.params['num_capsule'][0], + layer.shape['input'][0], layer.params['dim_capsule'][0]] + var b_shape = [layer.shape['input'][1], layer.params['num_capsule'][0]] + weight_params = w_shape[0] * w_shape[1] * w_shape[2] * w_shape[3] + bias_params = 2 * b_shape[0] * b_shape[1] + } else if(fc_layers.includes(layer.info.type)) { // if layer is one of Recurrent layer or Fully Connected layers calculate parameters using: // Num_Input * Num_Ouput From 46e14927635e7a639907614044efd587b550c592 Mon Sep 17 00:00:00 2001 From: namish800 Date: Tue, 11 Dec 2018 05:25:34 +0530 Subject: [PATCH 09/12] Added capsnet.png for the model --- example/keras/{Capsnet.json => capsnet.json} | 0 ide/static/img/zoo/capsnet.png | Bin 0 -> 19412 bytes ide/static/js/modelZoo.js | 2 +- 3 files changed, 1 insertion(+), 1 deletion(-) rename example/keras/{Capsnet.json => capsnet.json} (100%) create mode 100644 ide/static/img/zoo/capsnet.png diff --git a/example/keras/Capsnet.json b/example/keras/capsnet.json similarity index 100% rename from example/keras/Capsnet.json rename to example/keras/capsnet.json diff --git a/ide/static/img/zoo/capsnet.png b/ide/static/img/zoo/capsnet.png new file mode 100644 index 0000000000000000000000000000000000000000..b502c4db3a5f437a0b3633e4a3a0567ed174c98d GIT binary patch literal 19412 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 literal 0 HcmV?d00001 diff --git a/ide/static/js/modelZoo.js b/ide/static/js/modelZoo.js index bc1ab9ac5..754ac95cc 100644 --- a/ide/static/js/modelZoo.js +++ b/ide/static/js/modelZoo.js @@ -130,7 +130,6 @@ class ModelZoo extends React.Component { this.mouseClick(event, "vqa")}>VQA ->>>>>>> bd7ecadcceba337d7751fc1d41ce2ba23768a545
@@ -152,6 +151,7 @@ class ModelZoo extends React.Component { +
From 590520e3cf38663d844679961e6de73b489622b0 Mon Sep 17 00:00:00 2001 From: namish800 Date: Tue, 11 Dec 2018 05:38:59 +0530 Subject: [PATCH 10/12] Resolved check issue --- tests/unit/keras_app/test_views.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/keras_app/test_views.py b/tests/unit/keras_app/test_views.py index abaa531fa..2ada79bb0 100644 --- a/tests/unit/keras_app/test_views.py +++ b/tests/unit/keras_app/test_views.py @@ -704,7 +704,7 @@ def setUp(self): def test_keras_import_export(self): model_file = open(os.path.join(settings.BASE_DIR, 'example/keras', - 'Capsnet.json'), 'r') + 'capsnet.json'), 'r') response = self.client.post(reverse('keras-import'), {'file': model_file}) response = json.loads(response.content) net = get_shapes(response['net']) From f8ca30e9a7904288fd2bbb900f1251db63736356 Mon Sep 17 00:00:00 2001 From: namish800 Date: Tue, 11 Dec 2018 05:47:08 +0530 Subject: [PATCH 11/12] Resolved check issues. --- tests/unit/tensorflow_app/test_views.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/unit/tensorflow_app/test_views.py b/tests/unit/tensorflow_app/test_views.py index 0674af86c..f88e070fd 100644 --- a/tests/unit/tensorflow_app/test_views.py +++ b/tests/unit/tensorflow_app/test_views.py @@ -133,7 +133,7 @@ def setUp(self): def test_tf_export(self): model_file = open(os.path.join(settings.BASE_DIR, 'example/keras', - 'Capsnet.json'), 'r') + 'capsnet.json'), 'r') response = self.client.post(reverse('keras-import'), {'file': model_file}) response = json.loads(response.content) net = get_shapes(response['net']) From c023143f870865942a5a474b0cacd897c392ebf5 Mon Sep 17 00:00:00 2001 From: namish800 Date: Sun, 10 Feb 2019 16:00:01 +0530 Subject: [PATCH 12/12] Fixed travis-ci issues. --- ide/static/js/modelElement.js | 1 + ide/static/js/modelZoo.js | 2 +- tensorflow_app/views/import_graphdef.py | 11 ++++++++- tensorflow_app/views/layers_import.py | 30 +++++++++++++++++++++++++ 4 files changed, 42 insertions(+), 2 deletions(-) diff --git a/ide/static/js/modelElement.js b/ide/static/js/modelElement.js index dbf326e3b..c6c1d94d5 100644 --- a/ide/static/js/modelElement.js +++ b/ide/static/js/modelElement.js @@ -6,6 +6,7 @@ class ModelElement extends React.Component { } render() { if (this.props.children){ + console.log(this.props) return (
this.props.importNet('sample'+this.props.framework, this.props.id)}> diff --git a/ide/static/js/modelZoo.js b/ide/static/js/modelZoo.js index 0eb5318eb..d182aae7d 100644 --- a/ide/static/js/modelZoo.js +++ b/ide/static/js/modelZoo.js @@ -151,7 +151,7 @@ class ModelZoo extends React.Component { - +
diff --git a/tensorflow_app/views/import_graphdef.py b/tensorflow_app/views/import_graphdef.py index 26a3a0720..f1ac7f78b 100644 --- a/tensorflow_app/views/import_graphdef.py +++ b/tensorflow_app/views/import_graphdef.py @@ -9,7 +9,8 @@ from layers_import import import_placeholder, import_conv2d, import_conv3d, import_deconvolution, \ import_depthwise_convolution, import_pooling2d, import_pooling3d, \ import_inner_product, import_batchnorm, import_eltwise, import_activation, \ - import_dropout, import_flatten, import_concat, import_lrn + import_dropout, import_flatten, import_concat, import_lrn, \ + import_capsulelayer, import_maskcapsule, import_squash, import_length from layers_import import get_layer_name, get_layer_type, jsonLayer, activation_layers @@ -24,6 +25,10 @@ 'FusedBatchNorm': import_batchnorm, 'Conv2DBackpropInput': import_deconvolution, 'LRN': import_lrn, + 'CapsuleLayer': import_capsulelayer, + 'MaskCapsule': import_maskcapsule, + 'Squash': import_squash, + 'Length': import_length, 'MatMul': import_inner_product, 'Prod': import_inner_product, 'Concat': import_concat, @@ -35,6 +40,10 @@ 'flatten': import_flatten, 'dropout': import_dropout, 'lrn': import_lrn, + 'capsule_layer': import_capsulelayer, + 'mask_capsule': import_maskcapsule, + 'squash': import_squash, + 'length': import_length, 'concatenate': import_concat, 'batch': import_batchnorm, 'BatchNorm': import_batchnorm, diff --git a/tensorflow_app/views/layers_import.py b/tensorflow_app/views/layers_import.py index b284cdf75..07475bbfe 100644 --- a/tensorflow_app/views/layers_import.py +++ b/tensorflow_app/views/layers_import.py @@ -458,6 +458,36 @@ def import_lrn(layer_ops): return jsonLayer('LRN', layer_params, get_input_layers(layer_ops), []) +def import_capsulelayer(layer_ops): + layer_params = {} + for node in layer_ops: + if ('num_capsule' in node.node_def.attr): + layer_params['num_capsule'] = node.get_attr('num_capsule') + if ('dim_capsule' in node.node_def.attr): + layer_params['dim_capsule'] = node.get_attr('dim_capsule') + if ('num_routing' in node.node_def.attr): + layer_params['num_routing'] = node.get_attr('num_routing') + + return jsonLayer('CapsuleLayer', layer_params, get_input_layers(layer_ops), []) + + +def import_squash(layer_ops): + layer_params = {} + for node in layer_ops: + if ('axis' in node.node_def.attr): + layer_params['axis'] = node.get_attr('axis') + + return jsonLayer('Squash', layer_params, get_input_layers(layer_ops), []) + + +def import_maskcapsule(layer_ops): + return jsonLayer('MaskCapsule', [], get_input_layers(layer_ops), []) + + +def import_length(layer_ops): + return jsonLayer('Length', [], get_input_layers(layer_ops), []) + + def jsonLayer(layer_type, layer_params={}, inputs=[], outputs=[]): layer = { 'info': {