1 | case glow::Kinded::Kind::PadNodeKind: { |
2 | auto *N__ = llvm::cast<PadNode>(node); |
3 | opProto = graph.add_node(); |
4 | opProto->set_op_type("Glow_Pad" ); |
5 | opProto->set_name(glow::legalizeName(N__->getName())); |
6 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
7 | addTypeAttributes(opProto, N__, PadNode::InputIdx, /* isInput */ true); |
8 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
9 | addTypeAttributes(opProto, N__, PadNode::ResultIdx, /* isInput */ false); |
10 | addValueAttribute(opProto, "Mode" , N__->getMode()); |
11 | addValueAttribute(opProto, "Pads" , N__->getPads()); |
12 | addValueAttribute(opProto, "Value" , N__->getValue()); |
13 | if (N__->hasPredicate()) { |
14 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
15 | } |
16 | break; |
17 | } |
18 | |
19 | case glow::Kinded::Kind::ConvolutionGradNodeKind: { |
20 | auto *N__ = llvm::cast<ConvolutionGradNode>(node); |
21 | opProto = graph.add_node(); |
22 | opProto->set_op_type("Glow_ConvolutionGrad" ); |
23 | opProto->set_name(glow::legalizeName(N__->getName())); |
24 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
25 | addTypeAttributes(opProto, N__, ConvolutionGradNode::InputIdx, /* isInput */ true); |
26 | opProto->add_input(N__->getFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
27 | addTypeAttributes(opProto, N__, ConvolutionGradNode::FilterIdx, /* isInput */ true); |
28 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
29 | addTypeAttributes(opProto, N__, ConvolutionGradNode::BiasIdx, /* isInput */ true); |
30 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
31 | addTypeAttributes(opProto, N__, ConvolutionGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
32 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
33 | addTypeAttributes(opProto, N__, ConvolutionGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
34 | opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
35 | addTypeAttributes(opProto, N__, ConvolutionGradNode::GradOfInputNamedInputIdx, /* isInput */ false); |
36 | opProto->add_output(N__->getGradOfInputNamedFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
37 | addTypeAttributes(opProto, N__, ConvolutionGradNode::GradOfInputNamedFilterIdx, /* isInput */ false); |
38 | opProto->add_output(N__->getGradOfInputNamedBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
39 | addTypeAttributes(opProto, N__, ConvolutionGradNode::GradOfInputNamedBiasIdx, /* isInput */ false); |
40 | addValueAttribute(opProto, "Kernels" , N__->getKernels()); |
41 | addValueAttribute(opProto, "Strides" , N__->getStrides()); |
42 | addValueAttribute(opProto, "Pads" , N__->getPads()); |
43 | addValueAttribute(opProto, "Group" , N__->getGroup()); |
44 | addValueAttribute(opProto, "Dilation" , N__->getDilation()); |
45 | addValueAttribute(opProto, "Layout" , N__->getLayout()); |
46 | addValueAttribute(opProto, "FusedActivation" , N__->getFusedActivation()); |
47 | addValueAttribute(opProto, "FusedActivationArgs" , N__->getFusedActivationArgs()); |
48 | if (N__->hasPredicate()) { |
49 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
50 | } |
51 | break; |
52 | } |
53 | |
54 | case glow::Kinded::Kind::ConvolutionNodeKind: { |
55 | auto *N__ = llvm::cast<ConvolutionNode>(node); |
56 | opProto = graph.add_node(); |
57 | opProto->set_op_type("Glow_Convolution" ); |
58 | opProto->set_name(glow::legalizeName(N__->getName())); |
59 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
60 | addTypeAttributes(opProto, N__, ConvolutionNode::InputIdx, /* isInput */ true); |
61 | opProto->add_input(N__->getFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
62 | addTypeAttributes(opProto, N__, ConvolutionNode::FilterIdx, /* isInput */ true); |
63 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
64 | addTypeAttributes(opProto, N__, ConvolutionNode::BiasIdx, /* isInput */ true); |
65 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
66 | addTypeAttributes(opProto, N__, ConvolutionNode::ResultIdx, /* isInput */ false); |
67 | addValueAttribute(opProto, "Kernels" , N__->getKernels()); |
68 | addValueAttribute(opProto, "Strides" , N__->getStrides()); |
69 | addValueAttribute(opProto, "Pads" , N__->getPads()); |
70 | addValueAttribute(opProto, "Group" , N__->getGroup()); |
71 | addValueAttribute(opProto, "Dilation" , N__->getDilation()); |
72 | addValueAttribute(opProto, "Layout" , N__->getLayout()); |
73 | addValueAttribute(opProto, "FusedActivation" , N__->getFusedActivation()); |
74 | addValueAttribute(opProto, "FusedActivationArgs" , N__->getFusedActivationArgs()); |
75 | if (N__->hasPredicate()) { |
76 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
77 | } |
78 | break; |
79 | } |
80 | |
81 | case glow::Kinded::Kind::ChannelwiseQuantizedConvolutionNodeKind: { |
82 | auto *N__ = llvm::cast<ChannelwiseQuantizedConvolutionNode>(node); |
83 | opProto = graph.add_node(); |
84 | opProto->set_op_type("Glow_ChannelwiseQuantizedConvolution" ); |
85 | opProto->set_name(glow::legalizeName(N__->getName())); |
86 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
87 | addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::InputIdx, /* isInput */ true); |
88 | opProto->add_input(N__->getFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
89 | addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::FilterIdx, /* isInput */ true); |
90 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
91 | addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::BiasIdx, /* isInput */ true); |
92 | opProto->add_input(N__->getFilterScales().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
93 | addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::FilterScalesIdx, /* isInput */ true); |
94 | opProto->add_input(N__->getFilterOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
95 | addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::FilterOffsetsIdx, /* isInput */ true); |
96 | opProto->add_input(N__->getBiasScales().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
97 | addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::BiasScalesIdx, /* isInput */ true); |
98 | opProto->add_input(N__->getBiasOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
99 | addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::BiasOffsetsIdx, /* isInput */ true); |
100 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
101 | addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::ResultIdx, /* isInput */ false); |
102 | addValueAttribute(opProto, "Kernels" , N__->getKernels()); |
103 | addValueAttribute(opProto, "Strides" , N__->getStrides()); |
104 | addValueAttribute(opProto, "Pads" , N__->getPads()); |
105 | addValueAttribute(opProto, "Group" , N__->getGroup()); |
106 | addValueAttribute(opProto, "Dilation" , N__->getDilation()); |
107 | addValueAttribute(opProto, "FusedActivation" , N__->getFusedActivation()); |
108 | addValueAttribute(opProto, "FusedActivationArgs" , N__->getFusedActivationArgs()); |
109 | if (N__->hasPredicate()) { |
110 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
111 | } |
112 | break; |
113 | } |
114 | |
115 | case glow::Kinded::Kind::ConvTransposeNodeKind: { |
116 | auto *N__ = llvm::cast<ConvTransposeNode>(node); |
117 | opProto = graph.add_node(); |
118 | opProto->set_op_type("Glow_ConvTranspose" ); |
119 | opProto->set_name(glow::legalizeName(N__->getName())); |
120 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
121 | addTypeAttributes(opProto, N__, ConvTransposeNode::InputIdx, /* isInput */ true); |
122 | opProto->add_input(N__->getFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
123 | addTypeAttributes(opProto, N__, ConvTransposeNode::FilterIdx, /* isInput */ true); |
124 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
125 | addTypeAttributes(opProto, N__, ConvTransposeNode::BiasIdx, /* isInput */ true); |
126 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
127 | addTypeAttributes(opProto, N__, ConvTransposeNode::ResultIdx, /* isInput */ false); |
128 | addValueAttribute(opProto, "Kernels" , N__->getKernels()); |
129 | addValueAttribute(opProto, "Strides" , N__->getStrides()); |
130 | addValueAttribute(opProto, "Pads" , N__->getPads()); |
131 | addValueAttribute(opProto, "Group" , N__->getGroup()); |
132 | addValueAttribute(opProto, "Dilation" , N__->getDilation()); |
133 | if (N__->hasPredicate()) { |
134 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
135 | } |
136 | break; |
137 | } |
138 | |
139 | case glow::Kinded::Kind::Convolution3DGradNodeKind: { |
140 | auto *N__ = llvm::cast<Convolution3DGradNode>(node); |
141 | opProto = graph.add_node(); |
142 | opProto->set_op_type("Glow_Convolution3DGrad" ); |
143 | opProto->set_name(glow::legalizeName(N__->getName())); |
144 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
145 | addTypeAttributes(opProto, N__, Convolution3DGradNode::InputIdx, /* isInput */ true); |
146 | opProto->add_input(N__->getFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
147 | addTypeAttributes(opProto, N__, Convolution3DGradNode::FilterIdx, /* isInput */ true); |
148 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
149 | addTypeAttributes(opProto, N__, Convolution3DGradNode::BiasIdx, /* isInput */ true); |
150 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
151 | addTypeAttributes(opProto, N__, Convolution3DGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
152 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
153 | addTypeAttributes(opProto, N__, Convolution3DGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
154 | opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
155 | addTypeAttributes(opProto, N__, Convolution3DGradNode::GradOfInputNamedInputIdx, /* isInput */ false); |
156 | opProto->add_output(N__->getGradOfInputNamedFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
157 | addTypeAttributes(opProto, N__, Convolution3DGradNode::GradOfInputNamedFilterIdx, /* isInput */ false); |
158 | opProto->add_output(N__->getGradOfInputNamedBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
159 | addTypeAttributes(opProto, N__, Convolution3DGradNode::GradOfInputNamedBiasIdx, /* isInput */ false); |
160 | addValueAttribute(opProto, "Kernels" , N__->getKernels()); |
161 | addValueAttribute(opProto, "Strides" , N__->getStrides()); |
162 | addValueAttribute(opProto, "Pads" , N__->getPads()); |
163 | addValueAttribute(opProto, "Group" , N__->getGroup()); |
164 | if (N__->hasPredicate()) { |
165 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
166 | } |
167 | break; |
168 | } |
169 | |
170 | case glow::Kinded::Kind::Convolution3DNodeKind: { |
171 | auto *N__ = llvm::cast<Convolution3DNode>(node); |
172 | opProto = graph.add_node(); |
173 | opProto->set_op_type("Glow_Convolution3D" ); |
174 | opProto->set_name(glow::legalizeName(N__->getName())); |
175 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
176 | addTypeAttributes(opProto, N__, Convolution3DNode::InputIdx, /* isInput */ true); |
177 | opProto->add_input(N__->getFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
178 | addTypeAttributes(opProto, N__, Convolution3DNode::FilterIdx, /* isInput */ true); |
179 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
180 | addTypeAttributes(opProto, N__, Convolution3DNode::BiasIdx, /* isInput */ true); |
181 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
182 | addTypeAttributes(opProto, N__, Convolution3DNode::ResultIdx, /* isInput */ false); |
183 | addValueAttribute(opProto, "Kernels" , N__->getKernels()); |
184 | addValueAttribute(opProto, "Strides" , N__->getStrides()); |
185 | addValueAttribute(opProto, "Pads" , N__->getPads()); |
186 | addValueAttribute(opProto, "Group" , N__->getGroup()); |
187 | if (N__->hasPredicate()) { |
188 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
189 | } |
190 | break; |
191 | } |
192 | |
193 | case glow::Kinded::Kind::MaxPoolGradNodeKind: { |
194 | auto *N__ = llvm::cast<MaxPoolGradNode>(node); |
195 | opProto = graph.add_node(); |
196 | opProto->set_op_type("Glow_MaxPoolGrad" ); |
197 | opProto->set_name(glow::legalizeName(N__->getName())); |
198 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
199 | addTypeAttributes(opProto, N__, MaxPoolGradNode::InputIdx, /* isInput */ true); |
200 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
201 | addTypeAttributes(opProto, N__, MaxPoolGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
202 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
203 | addTypeAttributes(opProto, N__, MaxPoolGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
204 | opProto->add_input(N__->getOriginalOutputForArgmax().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
205 | addTypeAttributes(opProto, N__, MaxPoolGradNode::OriginalOutputForArgmaxIdx, /* isInput */ true); |
206 | opProto->add_input(N__->getGradOfOriginalOutputNamedArgmax().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
207 | addTypeAttributes(opProto, N__, MaxPoolGradNode::GradOfOriginalOutputNamedArgmaxIdx, /* isInput */ true); |
208 | opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
209 | addTypeAttributes(opProto, N__, MaxPoolGradNode::GradOfInputNamedInputIdx, /* isInput */ false); |
210 | addValueAttribute(opProto, "Kernels" , N__->getKernels()); |
211 | addValueAttribute(opProto, "Strides" , N__->getStrides()); |
212 | addValueAttribute(opProto, "Pads" , N__->getPads()); |
213 | addValueAttribute(opProto, "Layout" , N__->getLayout()); |
214 | if (N__->hasPredicate()) { |
215 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
216 | } |
217 | break; |
218 | } |
219 | |
220 | case glow::Kinded::Kind::MaxPoolNodeKind: { |
221 | auto *N__ = llvm::cast<MaxPoolNode>(node); |
222 | opProto = graph.add_node(); |
223 | opProto->set_op_type("Glow_MaxPool" ); |
224 | opProto->set_name(glow::legalizeName(N__->getName())); |
225 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
226 | addTypeAttributes(opProto, N__, MaxPoolNode::InputIdx, /* isInput */ true); |
227 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
228 | addTypeAttributes(opProto, N__, MaxPoolNode::ResultIdx, /* isInput */ false); |
229 | opProto->add_output(N__->getArgmax().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
230 | addTypeAttributes(opProto, N__, MaxPoolNode::ArgmaxIdx, /* isInput */ false); |
231 | addValueAttribute(opProto, "Kernels" , N__->getKernels()); |
232 | addValueAttribute(opProto, "Strides" , N__->getStrides()); |
233 | addValueAttribute(opProto, "Pads" , N__->getPads()); |
234 | addValueAttribute(opProto, "Layout" , N__->getLayout()); |
235 | if (N__->hasPredicate()) { |
236 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
237 | } |
238 | break; |
239 | } |
240 | |
241 | case glow::Kinded::Kind::ArgMaxNodeKind: { |
242 | auto *N__ = llvm::cast<ArgMaxNode>(node); |
243 | opProto = graph.add_node(); |
244 | opProto->set_op_type("Glow_ArgMax" ); |
245 | opProto->set_name(glow::legalizeName(N__->getName())); |
246 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
247 | addTypeAttributes(opProto, N__, ArgMaxNode::InputIdx, /* isInput */ true); |
248 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
249 | addTypeAttributes(opProto, N__, ArgMaxNode::ResultIdx, /* isInput */ false); |
250 | addValueAttribute(opProto, "Axis" , N__->getAxis()); |
251 | addValueAttribute(opProto, "KeepDims" , N__->getKeepDims()); |
252 | if (N__->hasPredicate()) { |
253 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
254 | } |
255 | break; |
256 | } |
257 | |
258 | case glow::Kinded::Kind::ArgMinNodeKind: { |
259 | auto *N__ = llvm::cast<ArgMinNode>(node); |
260 | opProto = graph.add_node(); |
261 | opProto->set_op_type("Glow_ArgMin" ); |
262 | opProto->set_name(glow::legalizeName(N__->getName())); |
263 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
264 | addTypeAttributes(opProto, N__, ArgMinNode::InputIdx, /* isInput */ true); |
265 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
266 | addTypeAttributes(opProto, N__, ArgMinNode::ResultIdx, /* isInput */ false); |
267 | addValueAttribute(opProto, "Axis" , N__->getAxis()); |
268 | addValueAttribute(opProto, "KeepDims" , N__->getKeepDims()); |
269 | if (N__->hasPredicate()) { |
270 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
271 | } |
272 | break; |
273 | } |
274 | |
275 | case glow::Kinded::Kind::AvgPoolGradNodeKind: { |
276 | auto *N__ = llvm::cast<AvgPoolGradNode>(node); |
277 | opProto = graph.add_node(); |
278 | opProto->set_op_type("Glow_AvgPoolGrad" ); |
279 | opProto->set_name(glow::legalizeName(N__->getName())); |
280 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
281 | addTypeAttributes(opProto, N__, AvgPoolGradNode::InputIdx, /* isInput */ true); |
282 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
283 | addTypeAttributes(opProto, N__, AvgPoolGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
284 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
285 | addTypeAttributes(opProto, N__, AvgPoolGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
286 | opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
287 | addTypeAttributes(opProto, N__, AvgPoolGradNode::GradOfInputNamedInputIdx, /* isInput */ false); |
288 | addValueAttribute(opProto, "Kernels" , N__->getKernels()); |
289 | addValueAttribute(opProto, "Strides" , N__->getStrides()); |
290 | addValueAttribute(opProto, "Pads" , N__->getPads()); |
291 | addValueAttribute(opProto, "Layout" , N__->getLayout()); |
292 | addValueAttribute(opProto, "CountIncludePads" , N__->getCountIncludePads()); |
293 | if (N__->hasPredicate()) { |
294 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
295 | } |
296 | break; |
297 | } |
298 | |
299 | case glow::Kinded::Kind::AvgPoolNodeKind: { |
300 | auto *N__ = llvm::cast<AvgPoolNode>(node); |
301 | opProto = graph.add_node(); |
302 | opProto->set_op_type("Glow_AvgPool" ); |
303 | opProto->set_name(glow::legalizeName(N__->getName())); |
304 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
305 | addTypeAttributes(opProto, N__, AvgPoolNode::InputIdx, /* isInput */ true); |
306 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
307 | addTypeAttributes(opProto, N__, AvgPoolNode::ResultIdx, /* isInput */ false); |
308 | addValueAttribute(opProto, "Kernels" , N__->getKernels()); |
309 | addValueAttribute(opProto, "Strides" , N__->getStrides()); |
310 | addValueAttribute(opProto, "Pads" , N__->getPads()); |
311 | addValueAttribute(opProto, "Layout" , N__->getLayout()); |
312 | addValueAttribute(opProto, "CountIncludePads" , N__->getCountIncludePads()); |
313 | if (N__->hasPredicate()) { |
314 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
315 | } |
316 | break; |
317 | } |
318 | |
319 | case glow::Kinded::Kind::AdaptiveAvgPoolGradNodeKind: { |
320 | auto *N__ = llvm::cast<AdaptiveAvgPoolGradNode>(node); |
321 | opProto = graph.add_node(); |
322 | opProto->set_op_type("Glow_AdaptiveAvgPoolGrad" ); |
323 | opProto->set_name(glow::legalizeName(N__->getName())); |
324 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
325 | addTypeAttributes(opProto, N__, AdaptiveAvgPoolGradNode::InputIdx, /* isInput */ true); |
326 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
327 | addTypeAttributes(opProto, N__, AdaptiveAvgPoolGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
328 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
329 | addTypeAttributes(opProto, N__, AdaptiveAvgPoolGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
330 | opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
331 | addTypeAttributes(opProto, N__, AdaptiveAvgPoolGradNode::GradOfInputNamedInputIdx, /* isInput */ false); |
332 | if (N__->hasPredicate()) { |
333 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
334 | } |
335 | break; |
336 | } |
337 | |
338 | case glow::Kinded::Kind::AdaptiveAvgPoolNodeKind: { |
339 | auto *N__ = llvm::cast<AdaptiveAvgPoolNode>(node); |
340 | opProto = graph.add_node(); |
341 | opProto->set_op_type("Glow_AdaptiveAvgPool" ); |
342 | opProto->set_name(glow::legalizeName(N__->getName())); |
343 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
344 | addTypeAttributes(opProto, N__, AdaptiveAvgPoolNode::InputIdx, /* isInput */ true); |
345 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
346 | addTypeAttributes(opProto, N__, AdaptiveAvgPoolNode::ResultIdx, /* isInput */ false); |
347 | if (N__->hasPredicate()) { |
348 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
349 | } |
350 | break; |
351 | } |
352 | |
353 | case glow::Kinded::Kind::GemmNodeKind: { |
354 | auto *N__ = llvm::cast<GemmNode>(node); |
355 | opProto = graph.add_node(); |
356 | opProto->set_op_type("Glow_Gemm" ); |
357 | opProto->set_name(glow::legalizeName(N__->getName())); |
358 | opProto->add_input(N__->getA().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
359 | addTypeAttributes(opProto, N__, GemmNode::AIdx, /* isInput */ true); |
360 | opProto->add_input(N__->getB().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
361 | addTypeAttributes(opProto, N__, GemmNode::BIdx, /* isInput */ true); |
362 | opProto->add_input(N__->getC().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
363 | addTypeAttributes(opProto, N__, GemmNode::CIdx, /* isInput */ true); |
364 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
365 | addTypeAttributes(opProto, N__, GemmNode::ResultIdx, /* isInput */ false); |
366 | addValueAttribute(opProto, "Alpha" , N__->getAlpha()); |
367 | addValueAttribute(opProto, "Beta" , N__->getBeta()); |
368 | addValueAttribute(opProto, "TransposeA" , N__->getTransposeA()); |
369 | addValueAttribute(opProto, "TransposeB" , N__->getTransposeB()); |
370 | if (N__->hasPredicate()) { |
371 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
372 | } |
373 | break; |
374 | } |
375 | |
376 | case glow::Kinded::Kind::FullyConnectedGradNodeKind: { |
377 | auto *N__ = llvm::cast<FullyConnectedGradNode>(node); |
378 | opProto = graph.add_node(); |
379 | opProto->set_op_type("Glow_FullyConnectedGrad" ); |
380 | opProto->set_name(glow::legalizeName(N__->getName())); |
381 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
382 | addTypeAttributes(opProto, N__, FullyConnectedGradNode::InputIdx, /* isInput */ true); |
383 | opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
384 | addTypeAttributes(opProto, N__, FullyConnectedGradNode::WeightsIdx, /* isInput */ true); |
385 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
386 | addTypeAttributes(opProto, N__, FullyConnectedGradNode::BiasIdx, /* isInput */ true); |
387 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
388 | addTypeAttributes(opProto, N__, FullyConnectedGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
389 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
390 | addTypeAttributes(opProto, N__, FullyConnectedGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
391 | opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
392 | addTypeAttributes(opProto, N__, FullyConnectedGradNode::GradOfInputNamedInputIdx, /* isInput */ false); |
393 | opProto->add_output(N__->getGradOfInputNamedWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
394 | addTypeAttributes(opProto, N__, FullyConnectedGradNode::GradOfInputNamedWeightsIdx, /* isInput */ false); |
395 | opProto->add_output(N__->getGradOfInputNamedBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
396 | addTypeAttributes(opProto, N__, FullyConnectedGradNode::GradOfInputNamedBiasIdx, /* isInput */ false); |
397 | if (N__->hasPredicate()) { |
398 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
399 | } |
400 | break; |
401 | } |
402 | |
403 | case glow::Kinded::Kind::FullyConnectedNodeKind: { |
404 | auto *N__ = llvm::cast<FullyConnectedNode>(node); |
405 | opProto = graph.add_node(); |
406 | opProto->set_op_type("Glow_FullyConnected" ); |
407 | opProto->set_name(glow::legalizeName(N__->getName())); |
408 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
409 | addTypeAttributes(opProto, N__, FullyConnectedNode::InputIdx, /* isInput */ true); |
410 | opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
411 | addTypeAttributes(opProto, N__, FullyConnectedNode::WeightsIdx, /* isInput */ true); |
412 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
413 | addTypeAttributes(opProto, N__, FullyConnectedNode::BiasIdx, /* isInput */ true); |
414 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
415 | addTypeAttributes(opProto, N__, FullyConnectedNode::ResultIdx, /* isInput */ false); |
416 | if (N__->hasPredicate()) { |
417 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
418 | } |
419 | break; |
420 | } |
421 | |
422 | case glow::Kinded::Kind::RowwiseQuantizedFullyConnectedNodeKind: { |
423 | auto *N__ = llvm::cast<RowwiseQuantizedFullyConnectedNode>(node); |
424 | opProto = graph.add_node(); |
425 | opProto->set_op_type("Glow_RowwiseQuantizedFullyConnected" ); |
426 | opProto->set_name(glow::legalizeName(N__->getName())); |
427 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
428 | addTypeAttributes(opProto, N__, RowwiseQuantizedFullyConnectedNode::InputIdx, /* isInput */ true); |
429 | opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
430 | addTypeAttributes(opProto, N__, RowwiseQuantizedFullyConnectedNode::WeightsIdx, /* isInput */ true); |
431 | opProto->add_input(N__->getScales().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
432 | addTypeAttributes(opProto, N__, RowwiseQuantizedFullyConnectedNode::ScalesIdx, /* isInput */ true); |
433 | opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
434 | addTypeAttributes(opProto, N__, RowwiseQuantizedFullyConnectedNode::OffsetsIdx, /* isInput */ true); |
435 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
436 | addTypeAttributes(opProto, N__, RowwiseQuantizedFullyConnectedNode::BiasIdx, /* isInput */ true); |
437 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
438 | addTypeAttributes(opProto, N__, RowwiseQuantizedFullyConnectedNode::ResultIdx, /* isInput */ false); |
439 | if (N__->hasPredicate()) { |
440 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
441 | } |
442 | break; |
443 | } |
444 | |
445 | case glow::Kinded::Kind::DynamicQuantizedFullyConnectedNodeKind: { |
446 | auto *N__ = llvm::cast<DynamicQuantizedFullyConnectedNode>(node); |
447 | opProto = graph.add_node(); |
448 | opProto->set_op_type("Glow_DynamicQuantizedFullyConnected" ); |
449 | opProto->set_name(glow::legalizeName(N__->getName())); |
450 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
451 | addTypeAttributes(opProto, N__, DynamicQuantizedFullyConnectedNode::InputIdx, /* isInput */ true); |
452 | opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
453 | addTypeAttributes(opProto, N__, DynamicQuantizedFullyConnectedNode::WeightsIdx, /* isInput */ true); |
454 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
455 | addTypeAttributes(opProto, N__, DynamicQuantizedFullyConnectedNode::BiasIdx, /* isInput */ true); |
456 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
457 | addTypeAttributes(opProto, N__, DynamicQuantizedFullyConnectedNode::ResultIdx, /* isInput */ false); |
458 | addValueAttribute(opProto, "IsSymmetric" , N__->getIsSymmetric()); |
459 | addValueAttribute(opProto, "IsPerBatchElement" , N__->getIsPerBatchElement()); |
460 | if (N__->hasPredicate()) { |
461 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
462 | } |
463 | break; |
464 | } |
465 | |
466 | case glow::Kinded::Kind::DynamicRowwiseQuantizedFullyConnectedNodeKind: { |
467 | auto *N__ = llvm::cast<DynamicRowwiseQuantizedFullyConnectedNode>(node); |
468 | opProto = graph.add_node(); |
469 | opProto->set_op_type("Glow_DynamicRowwiseQuantizedFullyConnected" ); |
470 | opProto->set_name(glow::legalizeName(N__->getName())); |
471 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
472 | addTypeAttributes(opProto, N__, DynamicRowwiseQuantizedFullyConnectedNode::InputIdx, /* isInput */ true); |
473 | opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
474 | addTypeAttributes(opProto, N__, DynamicRowwiseQuantizedFullyConnectedNode::WeightsIdx, /* isInput */ true); |
475 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
476 | addTypeAttributes(opProto, N__, DynamicRowwiseQuantizedFullyConnectedNode::BiasIdx, /* isInput */ true); |
477 | opProto->add_input(N__->getScales().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
478 | addTypeAttributes(opProto, N__, DynamicRowwiseQuantizedFullyConnectedNode::ScalesIdx, /* isInput */ true); |
479 | opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
480 | addTypeAttributes(opProto, N__, DynamicRowwiseQuantizedFullyConnectedNode::OffsetsIdx, /* isInput */ true); |
481 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
482 | addTypeAttributes(opProto, N__, DynamicRowwiseQuantizedFullyConnectedNode::ResultIdx, /* isInput */ false); |
483 | addValueAttribute(opProto, "IsSymmetric" , N__->getIsSymmetric()); |
484 | addValueAttribute(opProto, "IsPerBatchElement" , N__->getIsPerBatchElement()); |
485 | if (N__->hasPredicate()) { |
486 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
487 | } |
488 | break; |
489 | } |
490 | |
491 | case glow::Kinded::Kind::BatchNormalizationGradNodeKind: { |
492 | auto *N__ = llvm::cast<BatchNormalizationGradNode>(node); |
493 | opProto = graph.add_node(); |
494 | opProto->set_op_type("Glow_BatchNormalizationGrad" ); |
495 | opProto->set_name(glow::legalizeName(N__->getName())); |
496 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
497 | addTypeAttributes(opProto, N__, BatchNormalizationGradNode::InputIdx, /* isInput */ true); |
498 | opProto->add_input(N__->getScale().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
499 | addTypeAttributes(opProto, N__, BatchNormalizationGradNode::ScaleIdx, /* isInput */ true); |
500 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
501 | addTypeAttributes(opProto, N__, BatchNormalizationGradNode::BiasIdx, /* isInput */ true); |
502 | opProto->add_input(N__->getMean().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
503 | addTypeAttributes(opProto, N__, BatchNormalizationGradNode::MeanIdx, /* isInput */ true); |
504 | opProto->add_input(N__->getVar().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
505 | addTypeAttributes(opProto, N__, BatchNormalizationGradNode::VarIdx, /* isInput */ true); |
506 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
507 | addTypeAttributes(opProto, N__, BatchNormalizationGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
508 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
509 | addTypeAttributes(opProto, N__, BatchNormalizationGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
510 | opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
511 | addTypeAttributes(opProto, N__, BatchNormalizationGradNode::GradOfInputNamedInputIdx, /* isInput */ false); |
512 | opProto->add_output(N__->getGradOfInputNamedScale().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
513 | addTypeAttributes(opProto, N__, BatchNormalizationGradNode::GradOfInputNamedScaleIdx, /* isInput */ false); |
514 | opProto->add_output(N__->getGradOfInputNamedBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
515 | addTypeAttributes(opProto, N__, BatchNormalizationGradNode::GradOfInputNamedBiasIdx, /* isInput */ false); |
516 | opProto->add_output(N__->getGradOfInputNamedMean().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
517 | addTypeAttributes(opProto, N__, BatchNormalizationGradNode::GradOfInputNamedMeanIdx, /* isInput */ false); |
518 | opProto->add_output(N__->getGradOfInputNamedVar().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
519 | addTypeAttributes(opProto, N__, BatchNormalizationGradNode::GradOfInputNamedVarIdx, /* isInput */ false); |
520 | addValueAttribute(opProto, "ChannelIdx" , N__->getChannelIdx()); |
521 | addValueAttribute(opProto, "Epsilon" , N__->getEpsilon()); |
522 | addValueAttribute(opProto, "Momentum" , N__->getMomentum()); |
523 | if (N__->hasPredicate()) { |
524 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
525 | } |
526 | break; |
527 | } |
528 | |
529 | case glow::Kinded::Kind::BatchNormalizationNodeKind: { |
530 | auto *N__ = llvm::cast<BatchNormalizationNode>(node); |
531 | opProto = graph.add_node(); |
532 | opProto->set_op_type("Glow_BatchNormalization" ); |
533 | opProto->set_name(glow::legalizeName(N__->getName())); |
534 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
535 | addTypeAttributes(opProto, N__, BatchNormalizationNode::InputIdx, /* isInput */ true); |
536 | opProto->add_input(N__->getScale().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
537 | addTypeAttributes(opProto, N__, BatchNormalizationNode::ScaleIdx, /* isInput */ true); |
538 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
539 | addTypeAttributes(opProto, N__, BatchNormalizationNode::BiasIdx, /* isInput */ true); |
540 | opProto->add_input(N__->getMean().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
541 | addTypeAttributes(opProto, N__, BatchNormalizationNode::MeanIdx, /* isInput */ true); |
542 | opProto->add_input(N__->getVar().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
543 | addTypeAttributes(opProto, N__, BatchNormalizationNode::VarIdx, /* isInput */ true); |
544 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
545 | addTypeAttributes(opProto, N__, BatchNormalizationNode::ResultIdx, /* isInput */ false); |
546 | addValueAttribute(opProto, "ChannelIdx" , N__->getChannelIdx()); |
547 | addValueAttribute(opProto, "Epsilon" , N__->getEpsilon()); |
548 | addValueAttribute(opProto, "Momentum" , N__->getMomentum()); |
549 | if (N__->hasPredicate()) { |
550 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
551 | } |
552 | break; |
553 | } |
554 | |
555 | case glow::Kinded::Kind::InstanceNormalizationNodeKind: { |
556 | auto *N__ = llvm::cast<InstanceNormalizationNode>(node); |
557 | opProto = graph.add_node(); |
558 | opProto->set_op_type("Glow_InstanceNormalization" ); |
559 | opProto->set_name(glow::legalizeName(N__->getName())); |
560 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
561 | addTypeAttributes(opProto, N__, InstanceNormalizationNode::InputIdx, /* isInput */ true); |
562 | opProto->add_input(N__->getScale().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
563 | addTypeAttributes(opProto, N__, InstanceNormalizationNode::ScaleIdx, /* isInput */ true); |
564 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
565 | addTypeAttributes(opProto, N__, InstanceNormalizationNode::BiasIdx, /* isInput */ true); |
566 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
567 | addTypeAttributes(opProto, N__, InstanceNormalizationNode::ResultIdx, /* isInput */ false); |
568 | addValueAttribute(opProto, "ChannelIdx" , N__->getChannelIdx()); |
569 | addValueAttribute(opProto, "Epsilon" , N__->getEpsilon()); |
570 | if (N__->hasPredicate()) { |
571 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
572 | } |
573 | break; |
574 | } |
575 | |
576 | case glow::Kinded::Kind::MeanVarNormalizationNodeKind: { |
577 | auto *N__ = llvm::cast<MeanVarNormalizationNode>(node); |
578 | opProto = graph.add_node(); |
579 | opProto->set_op_type("Glow_MeanVarNormalization" ); |
580 | opProto->set_name(glow::legalizeName(N__->getName())); |
581 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
582 | addTypeAttributes(opProto, N__, MeanVarNormalizationNode::InputIdx, /* isInput */ true); |
583 | opProto->add_input(N__->getMean().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
584 | addTypeAttributes(opProto, N__, MeanVarNormalizationNode::MeanIdx, /* isInput */ true); |
585 | opProto->add_input(N__->getVar().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
586 | addTypeAttributes(opProto, N__, MeanVarNormalizationNode::VarIdx, /* isInput */ true); |
587 | opProto->add_output(N__->getNewMean().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
588 | addTypeAttributes(opProto, N__, MeanVarNormalizationNode::NewMeanIdx, /* isInput */ false); |
589 | opProto->add_output(N__->getNewVar().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
590 | addTypeAttributes(opProto, N__, MeanVarNormalizationNode::NewVarIdx, /* isInput */ false); |
591 | addValueAttribute(opProto, "ChannelIdx" , N__->getChannelIdx()); |
592 | addValueAttribute(opProto, "Momentum" , N__->getMomentum()); |
593 | if (N__->hasPredicate()) { |
594 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
595 | } |
596 | break; |
597 | } |
598 | |
599 | case glow::Kinded::Kind::LocalResponseNormalizationGradNodeKind: { |
600 | auto *N__ = llvm::cast<LocalResponseNormalizationGradNode>(node); |
601 | opProto = graph.add_node(); |
602 | opProto->set_op_type("Glow_LocalResponseNormalizationGrad" ); |
603 | opProto->set_name(glow::legalizeName(N__->getName())); |
604 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
605 | addTypeAttributes(opProto, N__, LocalResponseNormalizationGradNode::InputIdx, /* isInput */ true); |
606 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
607 | addTypeAttributes(opProto, N__, LocalResponseNormalizationGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
608 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
609 | addTypeAttributes(opProto, N__, LocalResponseNormalizationGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
610 | opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
611 | addTypeAttributes(opProto, N__, LocalResponseNormalizationGradNode::GradOfInputNamedInputIdx, /* isInput */ false); |
612 | addValueAttribute(opProto, "HalfWindowSize" , N__->getHalfWindowSize()); |
613 | addValueAttribute(opProto, "Alpha" , N__->getAlpha()); |
614 | addValueAttribute(opProto, "Beta" , N__->getBeta()); |
615 | addValueAttribute(opProto, "K" , N__->getK()); |
616 | if (N__->hasPredicate()) { |
617 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
618 | } |
619 | break; |
620 | } |
621 | |
622 | case glow::Kinded::Kind::LocalResponseNormalizationNodeKind: { |
623 | auto *N__ = llvm::cast<LocalResponseNormalizationNode>(node); |
624 | opProto = graph.add_node(); |
625 | opProto->set_op_type("Glow_LocalResponseNormalization" ); |
626 | opProto->set_name(glow::legalizeName(N__->getName())); |
627 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
628 | addTypeAttributes(opProto, N__, LocalResponseNormalizationNode::InputIdx, /* isInput */ true); |
629 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
630 | addTypeAttributes(opProto, N__, LocalResponseNormalizationNode::ResultIdx, /* isInput */ false); |
631 | addValueAttribute(opProto, "HalfWindowSize" , N__->getHalfWindowSize()); |
632 | addValueAttribute(opProto, "Alpha" , N__->getAlpha()); |
633 | addValueAttribute(opProto, "Beta" , N__->getBeta()); |
634 | addValueAttribute(opProto, "K" , N__->getK()); |
635 | if (N__->hasPredicate()) { |
636 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
637 | } |
638 | break; |
639 | } |
640 | |
641 | case glow::Kinded::Kind::LayerNormalizationNodeKind: { |
642 | auto *N__ = llvm::cast<LayerNormalizationNode>(node); |
643 | opProto = graph.add_node(); |
644 | opProto->set_op_type("Glow_LayerNormalization" ); |
645 | opProto->set_name(glow::legalizeName(N__->getName())); |
646 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
647 | addTypeAttributes(opProto, N__, LayerNormalizationNode::InputIdx, /* isInput */ true); |
648 | opProto->add_input(N__->getScale().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
649 | addTypeAttributes(opProto, N__, LayerNormalizationNode::ScaleIdx, /* isInput */ true); |
650 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
651 | addTypeAttributes(opProto, N__, LayerNormalizationNode::BiasIdx, /* isInput */ true); |
652 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
653 | addTypeAttributes(opProto, N__, LayerNormalizationNode::ResultIdx, /* isInput */ false); |
654 | addValueAttribute(opProto, "Epsilon" , N__->getEpsilon()); |
655 | if (N__->hasPredicate()) { |
656 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
657 | } |
658 | break; |
659 | } |
660 | |
661 | case glow::Kinded::Kind::BatchBoxCoxNodeKind: { |
662 | auto *N__ = llvm::cast<BatchBoxCoxNode>(node); |
663 | opProto = graph.add_node(); |
664 | opProto->set_op_type("Glow_BatchBoxCox" ); |
665 | opProto->set_name(glow::legalizeName(N__->getName())); |
666 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
667 | addTypeAttributes(opProto, N__, BatchBoxCoxNode::InputIdx, /* isInput */ true); |
668 | opProto->add_input(N__->getLambda1().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
669 | addTypeAttributes(opProto, N__, BatchBoxCoxNode::Lambda1Idx, /* isInput */ true); |
670 | opProto->add_input(N__->getLambda2().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
671 | addTypeAttributes(opProto, N__, BatchBoxCoxNode::Lambda2Idx, /* isInput */ true); |
672 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
673 | addTypeAttributes(opProto, N__, BatchBoxCoxNode::ResultIdx, /* isInput */ false); |
674 | addValueAttribute(opProto, "Epsilon" , N__->getEpsilon()); |
675 | if (N__->hasPredicate()) { |
676 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
677 | } |
678 | break; |
679 | } |
680 | |
681 | case glow::Kinded::Kind::VectorNormNodeKind: { |
682 | auto *N__ = llvm::cast<VectorNormNode>(node); |
683 | opProto = graph.add_node(); |
684 | opProto->set_op_type("Glow_VectorNorm" ); |
685 | opProto->set_name(glow::legalizeName(N__->getName())); |
686 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
687 | addTypeAttributes(opProto, N__, VectorNormNode::InputIdx, /* isInput */ true); |
688 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
689 | addTypeAttributes(opProto, N__, VectorNormNode::ResultIdx, /* isInput */ false); |
690 | addValueAttribute(opProto, "Axis" , N__->getAxis()); |
691 | addValueAttribute(opProto, "P" , N__->getP()); |
692 | if (N__->hasPredicate()) { |
693 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
694 | } |
695 | break; |
696 | } |
697 | |
698 | case glow::Kinded::Kind::BucketizeNodeKind: { |
699 | auto *N__ = llvm::cast<BucketizeNode>(node); |
700 | opProto = graph.add_node(); |
701 | opProto->set_op_type("Glow_Bucketize" ); |
702 | opProto->set_name(glow::legalizeName(N__->getName())); |
703 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
704 | addTypeAttributes(opProto, N__, BucketizeNode::InputIdx, /* isInput */ true); |
705 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
706 | addTypeAttributes(opProto, N__, BucketizeNode::ResultIdx, /* isInput */ false); |
707 | addValueAttribute(opProto, "Boundaries" , N__->getBoundaries()); |
708 | if (N__->hasPredicate()) { |
709 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
710 | } |
711 | break; |
712 | } |
713 | |
714 | case glow::Kinded::Kind::SoftMaxGradNodeKind: { |
715 | auto *N__ = llvm::cast<SoftMaxGradNode>(node); |
716 | opProto = graph.add_node(); |
717 | opProto->set_op_type("Glow_SoftMaxGrad" ); |
718 | opProto->set_name(glow::legalizeName(N__->getName())); |
719 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
720 | addTypeAttributes(opProto, N__, SoftMaxGradNode::InputIdx, /* isInput */ true); |
721 | opProto->add_input(N__->getSelected().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
722 | addTypeAttributes(opProto, N__, SoftMaxGradNode::SelectedIdx, /* isInput */ true); |
723 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
724 | addTypeAttributes(opProto, N__, SoftMaxGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
725 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
726 | addTypeAttributes(opProto, N__, SoftMaxGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
727 | opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
728 | addTypeAttributes(opProto, N__, SoftMaxGradNode::GradOfInputNamedInputIdx, /* isInput */ false); |
729 | opProto->add_output(N__->getGradOfInputNamedSelected().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
730 | addTypeAttributes(opProto, N__, SoftMaxGradNode::GradOfInputNamedSelectedIdx, /* isInput */ false); |
731 | if (N__->hasPredicate()) { |
732 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
733 | } |
734 | break; |
735 | } |
736 | |
737 | case glow::Kinded::Kind::SoftMaxNodeKind: { |
738 | auto *N__ = llvm::cast<SoftMaxNode>(node); |
739 | opProto = graph.add_node(); |
740 | opProto->set_op_type("Glow_SoftMax" ); |
741 | opProto->set_name(glow::legalizeName(N__->getName())); |
742 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
743 | addTypeAttributes(opProto, N__, SoftMaxNode::InputIdx, /* isInput */ true); |
744 | opProto->add_input(N__->getSelected().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
745 | addTypeAttributes(opProto, N__, SoftMaxNode::SelectedIdx, /* isInput */ true); |
746 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
747 | addTypeAttributes(opProto, N__, SoftMaxNode::ResultIdx, /* isInput */ false); |
748 | if (N__->hasPredicate()) { |
749 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
750 | } |
751 | break; |
752 | } |
753 | |
754 | case glow::Kinded::Kind::LogSoftMaxGradNodeKind: { |
755 | auto *N__ = llvm::cast<LogSoftMaxGradNode>(node); |
756 | opProto = graph.add_node(); |
757 | opProto->set_op_type("Glow_LogSoftMaxGrad" ); |
758 | opProto->set_name(glow::legalizeName(N__->getName())); |
759 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
760 | addTypeAttributes(opProto, N__, LogSoftMaxGradNode::InputIdx, /* isInput */ true); |
761 | opProto->add_input(N__->getSelected().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
762 | addTypeAttributes(opProto, N__, LogSoftMaxGradNode::SelectedIdx, /* isInput */ true); |
763 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
764 | addTypeAttributes(opProto, N__, LogSoftMaxGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
765 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
766 | addTypeAttributes(opProto, N__, LogSoftMaxGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
767 | opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
768 | addTypeAttributes(opProto, N__, LogSoftMaxGradNode::GradOfInputNamedInputIdx, /* isInput */ false); |
769 | opProto->add_output(N__->getGradOfInputNamedSelected().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
770 | addTypeAttributes(opProto, N__, LogSoftMaxGradNode::GradOfInputNamedSelectedIdx, /* isInput */ false); |
771 | if (N__->hasPredicate()) { |
772 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
773 | } |
774 | break; |
775 | } |
776 | |
777 | case glow::Kinded::Kind::LogSoftMaxNodeKind: { |
778 | auto *N__ = llvm::cast<LogSoftMaxNode>(node); |
779 | opProto = graph.add_node(); |
780 | opProto->set_op_type("Glow_LogSoftMax" ); |
781 | opProto->set_name(glow::legalizeName(N__->getName())); |
782 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
783 | addTypeAttributes(opProto, N__, LogSoftMaxNode::InputIdx, /* isInput */ true); |
784 | opProto->add_input(N__->getSelected().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
785 | addTypeAttributes(opProto, N__, LogSoftMaxNode::SelectedIdx, /* isInput */ true); |
786 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
787 | addTypeAttributes(opProto, N__, LogSoftMaxNode::ResultIdx, /* isInput */ false); |
788 | if (N__->hasPredicate()) { |
789 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
790 | } |
791 | break; |
792 | } |
793 | |
794 | case glow::Kinded::Kind::CrossEntropyLossGradNodeKind: { |
795 | auto *N__ = llvm::cast<CrossEntropyLossGradNode>(node); |
796 | opProto = graph.add_node(); |
797 | opProto->set_op_type("Glow_CrossEntropyLossGrad" ); |
798 | opProto->set_name(glow::legalizeName(N__->getName())); |
799 | opProto->add_input(N__->getP().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
800 | addTypeAttributes(opProto, N__, CrossEntropyLossGradNode::PIdx, /* isInput */ true); |
801 | opProto->add_input(N__->getLabels().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
802 | addTypeAttributes(opProto, N__, CrossEntropyLossGradNode::LabelsIdx, /* isInput */ true); |
803 | opProto->add_input(N__->getOriginalOutputForCE().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
804 | addTypeAttributes(opProto, N__, CrossEntropyLossGradNode::OriginalOutputForCEIdx, /* isInput */ true); |
805 | opProto->add_input(N__->getGradOfOriginalOutputNamedCE().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
806 | addTypeAttributes(opProto, N__, CrossEntropyLossGradNode::GradOfOriginalOutputNamedCEIdx, /* isInput */ true); |
807 | opProto->add_output(N__->getGradOfInputNamedP().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
808 | addTypeAttributes(opProto, N__, CrossEntropyLossGradNode::GradOfInputNamedPIdx, /* isInput */ false); |
809 | opProto->add_output(N__->getGradOfInputNamedLabels().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
810 | addTypeAttributes(opProto, N__, CrossEntropyLossGradNode::GradOfInputNamedLabelsIdx, /* isInput */ false); |
811 | if (N__->hasPredicate()) { |
812 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
813 | } |
814 | break; |
815 | } |
816 | |
817 | case glow::Kinded::Kind::CrossEntropyLossNodeKind: { |
818 | auto *N__ = llvm::cast<CrossEntropyLossNode>(node); |
819 | opProto = graph.add_node(); |
820 | opProto->set_op_type("Glow_CrossEntropyLoss" ); |
821 | opProto->set_name(glow::legalizeName(N__->getName())); |
822 | opProto->add_input(N__->getP().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
823 | addTypeAttributes(opProto, N__, CrossEntropyLossNode::PIdx, /* isInput */ true); |
824 | opProto->add_input(N__->getLabels().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
825 | addTypeAttributes(opProto, N__, CrossEntropyLossNode::LabelsIdx, /* isInput */ true); |
826 | opProto->add_output(N__->getCE().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
827 | addTypeAttributes(opProto, N__, CrossEntropyLossNode::CEIdx, /* isInput */ false); |
828 | if (N__->hasPredicate()) { |
829 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
830 | } |
831 | break; |
832 | } |
833 | |
834 | case glow::Kinded::Kind::RegressionGradNodeKind: { |
835 | auto *N__ = llvm::cast<RegressionGradNode>(node); |
836 | opProto = graph.add_node(); |
837 | opProto->set_op_type("Glow_RegressionGrad" ); |
838 | opProto->set_name(glow::legalizeName(N__->getName())); |
839 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
840 | addTypeAttributes(opProto, N__, RegressionGradNode::InputIdx, /* isInput */ true); |
841 | opProto->add_input(N__->getExpected().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
842 | addTypeAttributes(opProto, N__, RegressionGradNode::ExpectedIdx, /* isInput */ true); |
843 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
844 | addTypeAttributes(opProto, N__, RegressionGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
845 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
846 | addTypeAttributes(opProto, N__, RegressionGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
847 | opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
848 | addTypeAttributes(opProto, N__, RegressionGradNode::GradOfInputNamedInputIdx, /* isInput */ false); |
849 | opProto->add_output(N__->getGradOfInputNamedExpected().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
850 | addTypeAttributes(opProto, N__, RegressionGradNode::GradOfInputNamedExpectedIdx, /* isInput */ false); |
851 | if (N__->hasPredicate()) { |
852 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
853 | } |
854 | break; |
855 | } |
856 | |
857 | case glow::Kinded::Kind::RegressionNodeKind: { |
858 | auto *N__ = llvm::cast<RegressionNode>(node); |
859 | opProto = graph.add_node(); |
860 | opProto->set_op_type("Glow_Regression" ); |
861 | opProto->set_name(glow::legalizeName(N__->getName())); |
862 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
863 | addTypeAttributes(opProto, N__, RegressionNode::InputIdx, /* isInput */ true); |
864 | opProto->add_input(N__->getExpected().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
865 | addTypeAttributes(opProto, N__, RegressionNode::ExpectedIdx, /* isInput */ true); |
866 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
867 | addTypeAttributes(opProto, N__, RegressionNode::ResultIdx, /* isInput */ false); |
868 | if (N__->hasPredicate()) { |
869 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
870 | } |
871 | break; |
872 | } |
873 | |
874 | case glow::Kinded::Kind::SigmoidCrossEntropyWithLogitsNodeKind: { |
875 | auto *N__ = llvm::cast<SigmoidCrossEntropyWithLogitsNode>(node); |
876 | opProto = graph.add_node(); |
877 | opProto->set_op_type("Glow_SigmoidCrossEntropyWithLogits" ); |
878 | opProto->set_name(glow::legalizeName(N__->getName())); |
879 | opProto->add_input(N__->getLogits().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
880 | addTypeAttributes(opProto, N__, SigmoidCrossEntropyWithLogitsNode::LogitsIdx, /* isInput */ true); |
881 | opProto->add_input(N__->getTargets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
882 | addTypeAttributes(opProto, N__, SigmoidCrossEntropyWithLogitsNode::TargetsIdx, /* isInput */ true); |
883 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
884 | addTypeAttributes(opProto, N__, SigmoidCrossEntropyWithLogitsNode::ResultIdx, /* isInput */ false); |
885 | if (N__->hasPredicate()) { |
886 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
887 | } |
888 | break; |
889 | } |
890 | |
891 | case glow::Kinded::Kind::AddGradNodeKind: { |
892 | auto *N__ = llvm::cast<AddGradNode>(node); |
893 | opProto = graph.add_node(); |
894 | opProto->set_op_type("Glow_AddGrad" ); |
895 | opProto->set_name(glow::legalizeName(N__->getName())); |
896 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
897 | addTypeAttributes(opProto, N__, AddGradNode::LHSIdx, /* isInput */ true); |
898 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
899 | addTypeAttributes(opProto, N__, AddGradNode::RHSIdx, /* isInput */ true); |
900 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
901 | addTypeAttributes(opProto, N__, AddGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
902 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
903 | addTypeAttributes(opProto, N__, AddGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
904 | opProto->add_output(N__->getGradOfInputNamedLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
905 | addTypeAttributes(opProto, N__, AddGradNode::GradOfInputNamedLHSIdx, /* isInput */ false); |
906 | opProto->add_output(N__->getGradOfInputNamedRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
907 | addTypeAttributes(opProto, N__, AddGradNode::GradOfInputNamedRHSIdx, /* isInput */ false); |
908 | if (N__->hasPredicate()) { |
909 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
910 | } |
911 | break; |
912 | } |
913 | |
914 | case glow::Kinded::Kind::AddNodeKind: { |
915 | auto *N__ = llvm::cast<AddNode>(node); |
916 | opProto = graph.add_node(); |
917 | opProto->set_op_type("Glow_Add" ); |
918 | opProto->set_name(glow::legalizeName(N__->getName())); |
919 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
920 | addTypeAttributes(opProto, N__, AddNode::LHSIdx, /* isInput */ true); |
921 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
922 | addTypeAttributes(opProto, N__, AddNode::RHSIdx, /* isInput */ true); |
923 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
924 | addTypeAttributes(opProto, N__, AddNode::ResultIdx, /* isInput */ false); |
925 | if (N__->hasPredicate()) { |
926 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
927 | } |
928 | break; |
929 | } |
930 | |
931 | case glow::Kinded::Kind::MulGradNodeKind: { |
932 | auto *N__ = llvm::cast<MulGradNode>(node); |
933 | opProto = graph.add_node(); |
934 | opProto->set_op_type("Glow_MulGrad" ); |
935 | opProto->set_name(glow::legalizeName(N__->getName())); |
936 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
937 | addTypeAttributes(opProto, N__, MulGradNode::LHSIdx, /* isInput */ true); |
938 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
939 | addTypeAttributes(opProto, N__, MulGradNode::RHSIdx, /* isInput */ true); |
940 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
941 | addTypeAttributes(opProto, N__, MulGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
942 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
943 | addTypeAttributes(opProto, N__, MulGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
944 | opProto->add_output(N__->getGradOfInputNamedLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
945 | addTypeAttributes(opProto, N__, MulGradNode::GradOfInputNamedLHSIdx, /* isInput */ false); |
946 | opProto->add_output(N__->getGradOfInputNamedRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
947 | addTypeAttributes(opProto, N__, MulGradNode::GradOfInputNamedRHSIdx, /* isInput */ false); |
948 | if (N__->hasPredicate()) { |
949 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
950 | } |
951 | break; |
952 | } |
953 | |
954 | case glow::Kinded::Kind::MulNodeKind: { |
955 | auto *N__ = llvm::cast<MulNode>(node); |
956 | opProto = graph.add_node(); |
957 | opProto->set_op_type("Glow_Mul" ); |
958 | opProto->set_name(glow::legalizeName(N__->getName())); |
959 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
960 | addTypeAttributes(opProto, N__, MulNode::LHSIdx, /* isInput */ true); |
961 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
962 | addTypeAttributes(opProto, N__, MulNode::RHSIdx, /* isInput */ true); |
963 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
964 | addTypeAttributes(opProto, N__, MulNode::ResultIdx, /* isInput */ false); |
965 | if (N__->hasPredicate()) { |
966 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
967 | } |
968 | break; |
969 | } |
970 | |
971 | case glow::Kinded::Kind::SubGradNodeKind: { |
972 | auto *N__ = llvm::cast<SubGradNode>(node); |
973 | opProto = graph.add_node(); |
974 | opProto->set_op_type("Glow_SubGrad" ); |
975 | opProto->set_name(glow::legalizeName(N__->getName())); |
976 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
977 | addTypeAttributes(opProto, N__, SubGradNode::LHSIdx, /* isInput */ true); |
978 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
979 | addTypeAttributes(opProto, N__, SubGradNode::RHSIdx, /* isInput */ true); |
980 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
981 | addTypeAttributes(opProto, N__, SubGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
982 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
983 | addTypeAttributes(opProto, N__, SubGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
984 | opProto->add_output(N__->getGradOfInputNamedLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
985 | addTypeAttributes(opProto, N__, SubGradNode::GradOfInputNamedLHSIdx, /* isInput */ false); |
986 | opProto->add_output(N__->getGradOfInputNamedRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
987 | addTypeAttributes(opProto, N__, SubGradNode::GradOfInputNamedRHSIdx, /* isInput */ false); |
988 | if (N__->hasPredicate()) { |
989 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
990 | } |
991 | break; |
992 | } |
993 | |
994 | case glow::Kinded::Kind::SubNodeKind: { |
995 | auto *N__ = llvm::cast<SubNode>(node); |
996 | opProto = graph.add_node(); |
997 | opProto->set_op_type("Glow_Sub" ); |
998 | opProto->set_name(glow::legalizeName(N__->getName())); |
999 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1000 | addTypeAttributes(opProto, N__, SubNode::LHSIdx, /* isInput */ true); |
1001 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1002 | addTypeAttributes(opProto, N__, SubNode::RHSIdx, /* isInput */ true); |
1003 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1004 | addTypeAttributes(opProto, N__, SubNode::ResultIdx, /* isInput */ false); |
1005 | if (N__->hasPredicate()) { |
1006 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1007 | } |
1008 | break; |
1009 | } |
1010 | |
1011 | case glow::Kinded::Kind::DivGradNodeKind: { |
1012 | auto *N__ = llvm::cast<DivGradNode>(node); |
1013 | opProto = graph.add_node(); |
1014 | opProto->set_op_type("Glow_DivGrad" ); |
1015 | opProto->set_name(glow::legalizeName(N__->getName())); |
1016 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1017 | addTypeAttributes(opProto, N__, DivGradNode::LHSIdx, /* isInput */ true); |
1018 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1019 | addTypeAttributes(opProto, N__, DivGradNode::RHSIdx, /* isInput */ true); |
1020 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1021 | addTypeAttributes(opProto, N__, DivGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
1022 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1023 | addTypeAttributes(opProto, N__, DivGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
1024 | opProto->add_output(N__->getGradOfInputNamedLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1025 | addTypeAttributes(opProto, N__, DivGradNode::GradOfInputNamedLHSIdx, /* isInput */ false); |
1026 | opProto->add_output(N__->getGradOfInputNamedRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1027 | addTypeAttributes(opProto, N__, DivGradNode::GradOfInputNamedRHSIdx, /* isInput */ false); |
1028 | if (N__->hasPredicate()) { |
1029 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1030 | } |
1031 | break; |
1032 | } |
1033 | |
1034 | case glow::Kinded::Kind::DivNodeKind: { |
1035 | auto *N__ = llvm::cast<DivNode>(node); |
1036 | opProto = graph.add_node(); |
1037 | opProto->set_op_type("Glow_Div" ); |
1038 | opProto->set_name(glow::legalizeName(N__->getName())); |
1039 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1040 | addTypeAttributes(opProto, N__, DivNode::LHSIdx, /* isInput */ true); |
1041 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1042 | addTypeAttributes(opProto, N__, DivNode::RHSIdx, /* isInput */ true); |
1043 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1044 | addTypeAttributes(opProto, N__, DivNode::ResultIdx, /* isInput */ false); |
1045 | if (N__->hasPredicate()) { |
1046 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1047 | } |
1048 | break; |
1049 | } |
1050 | |
1051 | case glow::Kinded::Kind::FloorDivNodeKind: { |
1052 | auto *N__ = llvm::cast<FloorDivNode>(node); |
1053 | opProto = graph.add_node(); |
1054 | opProto->set_op_type("Glow_FloorDiv" ); |
1055 | opProto->set_name(glow::legalizeName(N__->getName())); |
1056 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1057 | addTypeAttributes(opProto, N__, FloorDivNode::LHSIdx, /* isInput */ true); |
1058 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1059 | addTypeAttributes(opProto, N__, FloorDivNode::RHSIdx, /* isInput */ true); |
1060 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1061 | addTypeAttributes(opProto, N__, FloorDivNode::ResultIdx, /* isInput */ false); |
1062 | addValueAttribute(opProto, "Truncate" , N__->getTruncate()); |
1063 | if (N__->hasPredicate()) { |
1064 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1065 | } |
1066 | break; |
1067 | } |
1068 | |
1069 | case glow::Kinded::Kind::FmodNodeKind: { |
1070 | auto *N__ = llvm::cast<FmodNode>(node); |
1071 | opProto = graph.add_node(); |
1072 | opProto->set_op_type("Glow_Fmod" ); |
1073 | opProto->set_name(glow::legalizeName(N__->getName())); |
1074 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1075 | addTypeAttributes(opProto, N__, FmodNode::LHSIdx, /* isInput */ true); |
1076 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1077 | addTypeAttributes(opProto, N__, FmodNode::RHSIdx, /* isInput */ true); |
1078 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1079 | addTypeAttributes(opProto, N__, FmodNode::ResultIdx, /* isInput */ false); |
1080 | if (N__->hasPredicate()) { |
1081 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1082 | } |
1083 | break; |
1084 | } |
1085 | |
1086 | case glow::Kinded::Kind::MaxNodeKind: { |
1087 | auto *N__ = llvm::cast<MaxNode>(node); |
1088 | opProto = graph.add_node(); |
1089 | opProto->set_op_type("Glow_Max" ); |
1090 | opProto->set_name(glow::legalizeName(N__->getName())); |
1091 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1092 | addTypeAttributes(opProto, N__, MaxNode::LHSIdx, /* isInput */ true); |
1093 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1094 | addTypeAttributes(opProto, N__, MaxNode::RHSIdx, /* isInput */ true); |
1095 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1096 | addTypeAttributes(opProto, N__, MaxNode::ResultIdx, /* isInput */ false); |
1097 | if (N__->hasPredicate()) { |
1098 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1099 | } |
1100 | break; |
1101 | } |
1102 | |
1103 | case glow::Kinded::Kind::MinNodeKind: { |
1104 | auto *N__ = llvm::cast<MinNode>(node); |
1105 | opProto = graph.add_node(); |
1106 | opProto->set_op_type("Glow_Min" ); |
1107 | opProto->set_name(glow::legalizeName(N__->getName())); |
1108 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1109 | addTypeAttributes(opProto, N__, MinNode::LHSIdx, /* isInput */ true); |
1110 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1111 | addTypeAttributes(opProto, N__, MinNode::RHSIdx, /* isInput */ true); |
1112 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1113 | addTypeAttributes(opProto, N__, MinNode::ResultIdx, /* isInput */ false); |
1114 | if (N__->hasPredicate()) { |
1115 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1116 | } |
1117 | break; |
1118 | } |
1119 | |
1120 | case glow::Kinded::Kind::CmpEQNodeKind: { |
1121 | auto *N__ = llvm::cast<CmpEQNode>(node); |
1122 | opProto = graph.add_node(); |
1123 | opProto->set_op_type("Glow_CmpEQ" ); |
1124 | opProto->set_name(glow::legalizeName(N__->getName())); |
1125 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1126 | addTypeAttributes(opProto, N__, CmpEQNode::LHSIdx, /* isInput */ true); |
1127 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1128 | addTypeAttributes(opProto, N__, CmpEQNode::RHSIdx, /* isInput */ true); |
1129 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1130 | addTypeAttributes(opProto, N__, CmpEQNode::ResultIdx, /* isInput */ false); |
1131 | if (N__->hasPredicate()) { |
1132 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1133 | } |
1134 | break; |
1135 | } |
1136 | |
1137 | case glow::Kinded::Kind::CmpNEQNodeKind: { |
1138 | auto *N__ = llvm::cast<CmpNEQNode>(node); |
1139 | opProto = graph.add_node(); |
1140 | opProto->set_op_type("Glow_CmpNEQ" ); |
1141 | opProto->set_name(glow::legalizeName(N__->getName())); |
1142 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1143 | addTypeAttributes(opProto, N__, CmpNEQNode::LHSIdx, /* isInput */ true); |
1144 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1145 | addTypeAttributes(opProto, N__, CmpNEQNode::RHSIdx, /* isInput */ true); |
1146 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1147 | addTypeAttributes(opProto, N__, CmpNEQNode::ResultIdx, /* isInput */ false); |
1148 | if (N__->hasPredicate()) { |
1149 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1150 | } |
1151 | break; |
1152 | } |
1153 | |
1154 | case glow::Kinded::Kind::CmpLTNodeKind: { |
1155 | auto *N__ = llvm::cast<CmpLTNode>(node); |
1156 | opProto = graph.add_node(); |
1157 | opProto->set_op_type("Glow_CmpLT" ); |
1158 | opProto->set_name(glow::legalizeName(N__->getName())); |
1159 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1160 | addTypeAttributes(opProto, N__, CmpLTNode::LHSIdx, /* isInput */ true); |
1161 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1162 | addTypeAttributes(opProto, N__, CmpLTNode::RHSIdx, /* isInput */ true); |
1163 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1164 | addTypeAttributes(opProto, N__, CmpLTNode::ResultIdx, /* isInput */ false); |
1165 | if (N__->hasPredicate()) { |
1166 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1167 | } |
1168 | break; |
1169 | } |
1170 | |
1171 | case glow::Kinded::Kind::CmpLTENodeKind: { |
1172 | auto *N__ = llvm::cast<CmpLTENode>(node); |
1173 | opProto = graph.add_node(); |
1174 | opProto->set_op_type("Glow_CmpLTE" ); |
1175 | opProto->set_name(glow::legalizeName(N__->getName())); |
1176 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1177 | addTypeAttributes(opProto, N__, CmpLTENode::LHSIdx, /* isInput */ true); |
1178 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1179 | addTypeAttributes(opProto, N__, CmpLTENode::RHSIdx, /* isInput */ true); |
1180 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1181 | addTypeAttributes(opProto, N__, CmpLTENode::ResultIdx, /* isInput */ false); |
1182 | if (N__->hasPredicate()) { |
1183 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1184 | } |
1185 | break; |
1186 | } |
1187 | |
1188 | case glow::Kinded::Kind::PowNodeKind: { |
1189 | auto *N__ = llvm::cast<PowNode>(node); |
1190 | opProto = graph.add_node(); |
1191 | opProto->set_op_type("Glow_Pow" ); |
1192 | opProto->set_name(glow::legalizeName(N__->getName())); |
1193 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1194 | addTypeAttributes(opProto, N__, PowNode::LHSIdx, /* isInput */ true); |
1195 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1196 | addTypeAttributes(opProto, N__, PowNode::RHSIdx, /* isInput */ true); |
1197 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1198 | addTypeAttributes(opProto, N__, PowNode::ResultIdx, /* isInput */ false); |
1199 | if (N__->hasPredicate()) { |
1200 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1201 | } |
1202 | break; |
1203 | } |
1204 | |
1205 | case glow::Kinded::Kind::AndNodeKind: { |
1206 | auto *N__ = llvm::cast<AndNode>(node); |
1207 | opProto = graph.add_node(); |
1208 | opProto->set_op_type("Glow_And" ); |
1209 | opProto->set_name(glow::legalizeName(N__->getName())); |
1210 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1211 | addTypeAttributes(opProto, N__, AndNode::LHSIdx, /* isInput */ true); |
1212 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1213 | addTypeAttributes(opProto, N__, AndNode::RHSIdx, /* isInput */ true); |
1214 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1215 | addTypeAttributes(opProto, N__, AndNode::ResultIdx, /* isInput */ false); |
1216 | if (N__->hasPredicate()) { |
1217 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1218 | } |
1219 | break; |
1220 | } |
1221 | |
1222 | case glow::Kinded::Kind::BitwiseAndNodeKind: { |
1223 | auto *N__ = llvm::cast<BitwiseAndNode>(node); |
1224 | opProto = graph.add_node(); |
1225 | opProto->set_op_type("Glow_BitwiseAnd" ); |
1226 | opProto->set_name(glow::legalizeName(N__->getName())); |
1227 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1228 | addTypeAttributes(opProto, N__, BitwiseAndNode::LHSIdx, /* isInput */ true); |
1229 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1230 | addTypeAttributes(opProto, N__, BitwiseAndNode::RHSIdx, /* isInput */ true); |
1231 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1232 | addTypeAttributes(opProto, N__, BitwiseAndNode::ResultIdx, /* isInput */ false); |
1233 | if (N__->hasPredicate()) { |
1234 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1235 | } |
1236 | break; |
1237 | } |
1238 | |
1239 | case glow::Kinded::Kind::OrNodeKind: { |
1240 | auto *N__ = llvm::cast<OrNode>(node); |
1241 | opProto = graph.add_node(); |
1242 | opProto->set_op_type("Glow_Or" ); |
1243 | opProto->set_name(glow::legalizeName(N__->getName())); |
1244 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1245 | addTypeAttributes(opProto, N__, OrNode::LHSIdx, /* isInput */ true); |
1246 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1247 | addTypeAttributes(opProto, N__, OrNode::RHSIdx, /* isInput */ true); |
1248 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1249 | addTypeAttributes(opProto, N__, OrNode::ResultIdx, /* isInput */ false); |
1250 | if (N__->hasPredicate()) { |
1251 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1252 | } |
1253 | break; |
1254 | } |
1255 | |
1256 | case glow::Kinded::Kind::BitwiseOrNodeKind: { |
1257 | auto *N__ = llvm::cast<BitwiseOrNode>(node); |
1258 | opProto = graph.add_node(); |
1259 | opProto->set_op_type("Glow_BitwiseOr" ); |
1260 | opProto->set_name(glow::legalizeName(N__->getName())); |
1261 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1262 | addTypeAttributes(opProto, N__, BitwiseOrNode::LHSIdx, /* isInput */ true); |
1263 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1264 | addTypeAttributes(opProto, N__, BitwiseOrNode::RHSIdx, /* isInput */ true); |
1265 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1266 | addTypeAttributes(opProto, N__, BitwiseOrNode::ResultIdx, /* isInput */ false); |
1267 | if (N__->hasPredicate()) { |
1268 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1269 | } |
1270 | break; |
1271 | } |
1272 | |
1273 | case glow::Kinded::Kind::XorNodeKind: { |
1274 | auto *N__ = llvm::cast<XorNode>(node); |
1275 | opProto = graph.add_node(); |
1276 | opProto->set_op_type("Glow_Xor" ); |
1277 | opProto->set_name(glow::legalizeName(N__->getName())); |
1278 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1279 | addTypeAttributes(opProto, N__, XorNode::LHSIdx, /* isInput */ true); |
1280 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1281 | addTypeAttributes(opProto, N__, XorNode::RHSIdx, /* isInput */ true); |
1282 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1283 | addTypeAttributes(opProto, N__, XorNode::ResultIdx, /* isInput */ false); |
1284 | if (N__->hasPredicate()) { |
1285 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1286 | } |
1287 | break; |
1288 | } |
1289 | |
1290 | case glow::Kinded::Kind::BitwiseXorNodeKind: { |
1291 | auto *N__ = llvm::cast<BitwiseXorNode>(node); |
1292 | opProto = graph.add_node(); |
1293 | opProto->set_op_type("Glow_BitwiseXor" ); |
1294 | opProto->set_name(glow::legalizeName(N__->getName())); |
1295 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1296 | addTypeAttributes(opProto, N__, BitwiseXorNode::LHSIdx, /* isInput */ true); |
1297 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1298 | addTypeAttributes(opProto, N__, BitwiseXorNode::RHSIdx, /* isInput */ true); |
1299 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1300 | addTypeAttributes(opProto, N__, BitwiseXorNode::ResultIdx, /* isInput */ false); |
1301 | if (N__->hasPredicate()) { |
1302 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1303 | } |
1304 | break; |
1305 | } |
1306 | |
1307 | case glow::Kinded::Kind::NotNodeKind: { |
1308 | auto *N__ = llvm::cast<NotNode>(node); |
1309 | opProto = graph.add_node(); |
1310 | opProto->set_op_type("Glow_Not" ); |
1311 | opProto->set_name(glow::legalizeName(N__->getName())); |
1312 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1313 | addTypeAttributes(opProto, N__, NotNode::InputIdx, /* isInput */ true); |
1314 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1315 | addTypeAttributes(opProto, N__, NotNode::ResultIdx, /* isInput */ false); |
1316 | if (N__->hasPredicate()) { |
1317 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1318 | } |
1319 | break; |
1320 | } |
1321 | |
1322 | case glow::Kinded::Kind::BitwiseNotNodeKind: { |
1323 | auto *N__ = llvm::cast<BitwiseNotNode>(node); |
1324 | opProto = graph.add_node(); |
1325 | opProto->set_op_type("Glow_BitwiseNot" ); |
1326 | opProto->set_name(glow::legalizeName(N__->getName())); |
1327 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1328 | addTypeAttributes(opProto, N__, BitwiseNotNode::InputIdx, /* isInput */ true); |
1329 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1330 | addTypeAttributes(opProto, N__, BitwiseNotNode::ResultIdx, /* isInput */ false); |
1331 | if (N__->hasPredicate()) { |
1332 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1333 | } |
1334 | break; |
1335 | } |
1336 | |
1337 | case glow::Kinded::Kind::NegNodeKind: { |
1338 | auto *N__ = llvm::cast<NegNode>(node); |
1339 | opProto = graph.add_node(); |
1340 | opProto->set_op_type("Glow_Neg" ); |
1341 | opProto->set_name(glow::legalizeName(N__->getName())); |
1342 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1343 | addTypeAttributes(opProto, N__, NegNode::InputIdx, /* isInput */ true); |
1344 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1345 | addTypeAttributes(opProto, N__, NegNode::ResultIdx, /* isInput */ false); |
1346 | if (N__->hasPredicate()) { |
1347 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1348 | } |
1349 | break; |
1350 | } |
1351 | |
1352 | case glow::Kinded::Kind::AbsNodeKind: { |
1353 | auto *N__ = llvm::cast<AbsNode>(node); |
1354 | opProto = graph.add_node(); |
1355 | opProto->set_op_type("Glow_Abs" ); |
1356 | opProto->set_name(glow::legalizeName(N__->getName())); |
1357 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1358 | addTypeAttributes(opProto, N__, AbsNode::InputIdx, /* isInput */ true); |
1359 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1360 | addTypeAttributes(opProto, N__, AbsNode::ResultIdx, /* isInput */ false); |
1361 | if (N__->hasPredicate()) { |
1362 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1363 | } |
1364 | break; |
1365 | } |
1366 | |
1367 | case glow::Kinded::Kind::FloorNodeKind: { |
1368 | auto *N__ = llvm::cast<FloorNode>(node); |
1369 | opProto = graph.add_node(); |
1370 | opProto->set_op_type("Glow_Floor" ); |
1371 | opProto->set_name(glow::legalizeName(N__->getName())); |
1372 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1373 | addTypeAttributes(opProto, N__, FloorNode::InputIdx, /* isInput */ true); |
1374 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1375 | addTypeAttributes(opProto, N__, FloorNode::ResultIdx, /* isInput */ false); |
1376 | if (N__->hasPredicate()) { |
1377 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1378 | } |
1379 | break; |
1380 | } |
1381 | |
1382 | case glow::Kinded::Kind::SignNodeKind: { |
1383 | auto *N__ = llvm::cast<SignNode>(node); |
1384 | opProto = graph.add_node(); |
1385 | opProto->set_op_type("Glow_Sign" ); |
1386 | opProto->set_name(glow::legalizeName(N__->getName())); |
1387 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1388 | addTypeAttributes(opProto, N__, SignNode::InputIdx, /* isInput */ true); |
1389 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1390 | addTypeAttributes(opProto, N__, SignNode::ResultIdx, /* isInput */ false); |
1391 | if (N__->hasPredicate()) { |
1392 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1393 | } |
1394 | break; |
1395 | } |
1396 | |
1397 | case glow::Kinded::Kind::CeilNodeKind: { |
1398 | auto *N__ = llvm::cast<CeilNode>(node); |
1399 | opProto = graph.add_node(); |
1400 | opProto->set_op_type("Glow_Ceil" ); |
1401 | opProto->set_name(glow::legalizeName(N__->getName())); |
1402 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1403 | addTypeAttributes(opProto, N__, CeilNode::InputIdx, /* isInput */ true); |
1404 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1405 | addTypeAttributes(opProto, N__, CeilNode::ResultIdx, /* isInput */ false); |
1406 | if (N__->hasPredicate()) { |
1407 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1408 | } |
1409 | break; |
1410 | } |
1411 | |
1412 | case glow::Kinded::Kind::RoundNodeKind: { |
1413 | auto *N__ = llvm::cast<RoundNode>(node); |
1414 | opProto = graph.add_node(); |
1415 | opProto->set_op_type("Glow_Round" ); |
1416 | opProto->set_name(glow::legalizeName(N__->getName())); |
1417 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1418 | addTypeAttributes(opProto, N__, RoundNode::InputIdx, /* isInput */ true); |
1419 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1420 | addTypeAttributes(opProto, N__, RoundNode::ResultIdx, /* isInput */ false); |
1421 | if (N__->hasPredicate()) { |
1422 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1423 | } |
1424 | break; |
1425 | } |
1426 | |
1427 | case glow::Kinded::Kind::TruncateNodeKind: { |
1428 | auto *N__ = llvm::cast<TruncateNode>(node); |
1429 | opProto = graph.add_node(); |
1430 | opProto->set_op_type("Glow_Truncate" ); |
1431 | opProto->set_name(glow::legalizeName(N__->getName())); |
1432 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1433 | addTypeAttributes(opProto, N__, TruncateNode::InputIdx, /* isInput */ true); |
1434 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1435 | addTypeAttributes(opProto, N__, TruncateNode::ResultIdx, /* isInput */ false); |
1436 | if (N__->hasPredicate()) { |
1437 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1438 | } |
1439 | break; |
1440 | } |
1441 | |
1442 | case glow::Kinded::Kind::SqrtNodeKind: { |
1443 | auto *N__ = llvm::cast<SqrtNode>(node); |
1444 | opProto = graph.add_node(); |
1445 | opProto->set_op_type("Glow_Sqrt" ); |
1446 | opProto->set_name(glow::legalizeName(N__->getName())); |
1447 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1448 | addTypeAttributes(opProto, N__, SqrtNode::InputIdx, /* isInput */ true); |
1449 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1450 | addTypeAttributes(opProto, N__, SqrtNode::ResultIdx, /* isInput */ false); |
1451 | if (N__->hasPredicate()) { |
1452 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1453 | } |
1454 | break; |
1455 | } |
1456 | |
1457 | case glow::Kinded::Kind::RsqrtNodeKind: { |
1458 | auto *N__ = llvm::cast<RsqrtNode>(node); |
1459 | opProto = graph.add_node(); |
1460 | opProto->set_op_type("Glow_Rsqrt" ); |
1461 | opProto->set_name(glow::legalizeName(N__->getName())); |
1462 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1463 | addTypeAttributes(opProto, N__, RsqrtNode::InputIdx, /* isInput */ true); |
1464 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1465 | addTypeAttributes(opProto, N__, RsqrtNode::ResultIdx, /* isInput */ false); |
1466 | if (N__->hasPredicate()) { |
1467 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1468 | } |
1469 | break; |
1470 | } |
1471 | |
1472 | case glow::Kinded::Kind::ReciprocalNodeKind: { |
1473 | auto *N__ = llvm::cast<ReciprocalNode>(node); |
1474 | opProto = graph.add_node(); |
1475 | opProto->set_op_type("Glow_Reciprocal" ); |
1476 | opProto->set_name(glow::legalizeName(N__->getName())); |
1477 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1478 | addTypeAttributes(opProto, N__, ReciprocalNode::InputIdx, /* isInput */ true); |
1479 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1480 | addTypeAttributes(opProto, N__, ReciprocalNode::ResultIdx, /* isInput */ false); |
1481 | if (N__->hasPredicate()) { |
1482 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1483 | } |
1484 | break; |
1485 | } |
1486 | |
1487 | case glow::Kinded::Kind::SinNodeKind: { |
1488 | auto *N__ = llvm::cast<SinNode>(node); |
1489 | opProto = graph.add_node(); |
1490 | opProto->set_op_type("Glow_Sin" ); |
1491 | opProto->set_name(glow::legalizeName(N__->getName())); |
1492 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1493 | addTypeAttributes(opProto, N__, SinNode::InputIdx, /* isInput */ true); |
1494 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1495 | addTypeAttributes(opProto, N__, SinNode::ResultIdx, /* isInput */ false); |
1496 | if (N__->hasPredicate()) { |
1497 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1498 | } |
1499 | break; |
1500 | } |
1501 | |
1502 | case glow::Kinded::Kind::CosNodeKind: { |
1503 | auto *N__ = llvm::cast<CosNode>(node); |
1504 | opProto = graph.add_node(); |
1505 | opProto->set_op_type("Glow_Cos" ); |
1506 | opProto->set_name(glow::legalizeName(N__->getName())); |
1507 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1508 | addTypeAttributes(opProto, N__, CosNode::InputIdx, /* isInput */ true); |
1509 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1510 | addTypeAttributes(opProto, N__, CosNode::ResultIdx, /* isInput */ false); |
1511 | if (N__->hasPredicate()) { |
1512 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1513 | } |
1514 | break; |
1515 | } |
1516 | |
1517 | case glow::Kinded::Kind::LogNodeKind: { |
1518 | auto *N__ = llvm::cast<LogNode>(node); |
1519 | opProto = graph.add_node(); |
1520 | opProto->set_op_type("Glow_Log" ); |
1521 | opProto->set_name(glow::legalizeName(N__->getName())); |
1522 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1523 | addTypeAttributes(opProto, N__, LogNode::InputIdx, /* isInput */ true); |
1524 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1525 | addTypeAttributes(opProto, N__, LogNode::ResultIdx, /* isInput */ false); |
1526 | if (N__->hasPredicate()) { |
1527 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1528 | } |
1529 | break; |
1530 | } |
1531 | |
1532 | case glow::Kinded::Kind::AcosNodeKind: { |
1533 | auto *N__ = llvm::cast<AcosNode>(node); |
1534 | opProto = graph.add_node(); |
1535 | opProto->set_op_type("Glow_Acos" ); |
1536 | opProto->set_name(glow::legalizeName(N__->getName())); |
1537 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1538 | addTypeAttributes(opProto, N__, AcosNode::InputIdx, /* isInput */ true); |
1539 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1540 | addTypeAttributes(opProto, N__, AcosNode::ResultIdx, /* isInput */ false); |
1541 | if (N__->hasPredicate()) { |
1542 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1543 | } |
1544 | break; |
1545 | } |
1546 | |
1547 | case glow::Kinded::Kind::AsinNodeKind: { |
1548 | auto *N__ = llvm::cast<AsinNode>(node); |
1549 | opProto = graph.add_node(); |
1550 | opProto->set_op_type("Glow_Asin" ); |
1551 | opProto->set_name(glow::legalizeName(N__->getName())); |
1552 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1553 | addTypeAttributes(opProto, N__, AsinNode::InputIdx, /* isInput */ true); |
1554 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1555 | addTypeAttributes(opProto, N__, AsinNode::ResultIdx, /* isInput */ false); |
1556 | if (N__->hasPredicate()) { |
1557 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1558 | } |
1559 | break; |
1560 | } |
1561 | |
1562 | case glow::Kinded::Kind::AtanNodeKind: { |
1563 | auto *N__ = llvm::cast<AtanNode>(node); |
1564 | opProto = graph.add_node(); |
1565 | opProto->set_op_type("Glow_Atan" ); |
1566 | opProto->set_name(glow::legalizeName(N__->getName())); |
1567 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1568 | addTypeAttributes(opProto, N__, AtanNode::InputIdx, /* isInput */ true); |
1569 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1570 | addTypeAttributes(opProto, N__, AtanNode::ResultIdx, /* isInput */ false); |
1571 | if (N__->hasPredicate()) { |
1572 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1573 | } |
1574 | break; |
1575 | } |
1576 | |
1577 | case glow::Kinded::Kind::ErfNodeKind: { |
1578 | auto *N__ = llvm::cast<ErfNode>(node); |
1579 | opProto = graph.add_node(); |
1580 | opProto->set_op_type("Glow_Erf" ); |
1581 | opProto->set_name(glow::legalizeName(N__->getName())); |
1582 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1583 | addTypeAttributes(opProto, N__, ErfNode::InputIdx, /* isInput */ true); |
1584 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1585 | addTypeAttributes(opProto, N__, ErfNode::ResultIdx, /* isInput */ false); |
1586 | if (N__->hasPredicate()) { |
1587 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1588 | } |
1589 | break; |
1590 | } |
1591 | |
1592 | case glow::Kinded::Kind::ExpNodeKind: { |
1593 | auto *N__ = llvm::cast<ExpNode>(node); |
1594 | opProto = graph.add_node(); |
1595 | opProto->set_op_type("Glow_Exp" ); |
1596 | opProto->set_name(glow::legalizeName(N__->getName())); |
1597 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1598 | addTypeAttributes(opProto, N__, ExpNode::InputIdx, /* isInput */ true); |
1599 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1600 | addTypeAttributes(opProto, N__, ExpNode::ResultIdx, /* isInput */ false); |
1601 | if (N__->hasPredicate()) { |
1602 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1603 | } |
1604 | break; |
1605 | } |
1606 | |
1607 | case glow::Kinded::Kind::LogitNodeKind: { |
1608 | auto *N__ = llvm::cast<LogitNode>(node); |
1609 | opProto = graph.add_node(); |
1610 | opProto->set_op_type("Glow_Logit" ); |
1611 | opProto->set_name(glow::legalizeName(N__->getName())); |
1612 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1613 | addTypeAttributes(opProto, N__, LogitNode::InputIdx, /* isInput */ true); |
1614 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1615 | addTypeAttributes(opProto, N__, LogitNode::ResultIdx, /* isInput */ false); |
1616 | addValueAttribute(opProto, "Epsilon" , N__->getEpsilon()); |
1617 | if (N__->hasPredicate()) { |
1618 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1619 | } |
1620 | break; |
1621 | } |
1622 | |
1623 | case glow::Kinded::Kind::NonZeroNodeKind: { |
1624 | auto *N__ = llvm::cast<NonZeroNode>(node); |
1625 | opProto = graph.add_node(); |
1626 | opProto->set_op_type("Glow_NonZero" ); |
1627 | opProto->set_name(glow::legalizeName(N__->getName())); |
1628 | opProto->add_input(N__->getCond().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1629 | addTypeAttributes(opProto, N__, NonZeroNode::CondIdx, /* isInput */ true); |
1630 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1631 | addTypeAttributes(opProto, N__, NonZeroNode::ResultIdx, /* isInput */ false); |
1632 | if (N__->hasPredicate()) { |
1633 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1634 | } |
1635 | break; |
1636 | } |
1637 | |
1638 | case glow::Kinded::Kind::SelectNodeKind: { |
1639 | auto *N__ = llvm::cast<SelectNode>(node); |
1640 | opProto = graph.add_node(); |
1641 | opProto->set_op_type("Glow_Select" ); |
1642 | opProto->set_name(glow::legalizeName(N__->getName())); |
1643 | opProto->add_input(N__->getCond().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1644 | addTypeAttributes(opProto, N__, SelectNode::CondIdx, /* isInput */ true); |
1645 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1646 | addTypeAttributes(opProto, N__, SelectNode::LHSIdx, /* isInput */ true); |
1647 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1648 | addTypeAttributes(opProto, N__, SelectNode::RHSIdx, /* isInput */ true); |
1649 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1650 | addTypeAttributes(opProto, N__, SelectNode::ResultIdx, /* isInput */ false); |
1651 | if (N__->hasPredicate()) { |
1652 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1653 | } |
1654 | break; |
1655 | } |
1656 | |
1657 | case glow::Kinded::Kind::BatchedAddNodeKind: { |
1658 | auto *N__ = llvm::cast<BatchedAddNode>(node); |
1659 | opProto = graph.add_node(); |
1660 | opProto->set_op_type("Glow_BatchedAdd" ); |
1661 | opProto->set_name(glow::legalizeName(N__->getName())); |
1662 | opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1663 | addTypeAttributes(opProto, N__, BatchedAddNode::BatchIdx, /* isInput */ true); |
1664 | opProto->add_input(N__->getSlice().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1665 | addTypeAttributes(opProto, N__, BatchedAddNode::SliceIdx, /* isInput */ true); |
1666 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1667 | addTypeAttributes(opProto, N__, BatchedAddNode::ResultIdx, /* isInput */ false); |
1668 | if (N__->hasPredicate()) { |
1669 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1670 | } |
1671 | break; |
1672 | } |
1673 | |
1674 | case glow::Kinded::Kind::BatchedMulNodeKind: { |
1675 | auto *N__ = llvm::cast<BatchedMulNode>(node); |
1676 | opProto = graph.add_node(); |
1677 | opProto->set_op_type("Glow_BatchedMul" ); |
1678 | opProto->set_name(glow::legalizeName(N__->getName())); |
1679 | opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1680 | addTypeAttributes(opProto, N__, BatchedMulNode::BatchIdx, /* isInput */ true); |
1681 | opProto->add_input(N__->getSlice().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1682 | addTypeAttributes(opProto, N__, BatchedMulNode::SliceIdx, /* isInput */ true); |
1683 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1684 | addTypeAttributes(opProto, N__, BatchedMulNode::ResultIdx, /* isInput */ false); |
1685 | if (N__->hasPredicate()) { |
1686 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1687 | } |
1688 | break; |
1689 | } |
1690 | |
1691 | case glow::Kinded::Kind::MatMulNodeKind: { |
1692 | auto *N__ = llvm::cast<MatMulNode>(node); |
1693 | opProto = graph.add_node(); |
1694 | opProto->set_op_type("Glow_MatMul" ); |
1695 | opProto->set_name(glow::legalizeName(N__->getName())); |
1696 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1697 | addTypeAttributes(opProto, N__, MatMulNode::LHSIdx, /* isInput */ true); |
1698 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1699 | addTypeAttributes(opProto, N__, MatMulNode::RHSIdx, /* isInput */ true); |
1700 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1701 | addTypeAttributes(opProto, N__, MatMulNode::ResultIdx, /* isInput */ false); |
1702 | if (N__->hasPredicate()) { |
1703 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1704 | } |
1705 | break; |
1706 | } |
1707 | |
1708 | case glow::Kinded::Kind::BatchMatMulNodeKind: { |
1709 | auto *N__ = llvm::cast<BatchMatMulNode>(node); |
1710 | opProto = graph.add_node(); |
1711 | opProto->set_op_type("Glow_BatchMatMul" ); |
1712 | opProto->set_name(glow::legalizeName(N__->getName())); |
1713 | opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1714 | addTypeAttributes(opProto, N__, BatchMatMulNode::LHSIdx, /* isInput */ true); |
1715 | opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1716 | addTypeAttributes(opProto, N__, BatchMatMulNode::RHSIdx, /* isInput */ true); |
1717 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1718 | addTypeAttributes(opProto, N__, BatchMatMulNode::ResultIdx, /* isInput */ false); |
1719 | if (N__->hasPredicate()) { |
1720 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1721 | } |
1722 | break; |
1723 | } |
1724 | |
1725 | case glow::Kinded::Kind::BatchedReduceAddNodeKind: { |
1726 | auto *N__ = llvm::cast<BatchedReduceAddNode>(node); |
1727 | opProto = graph.add_node(); |
1728 | opProto->set_op_type("Glow_BatchedReduceAdd" ); |
1729 | opProto->set_name(glow::legalizeName(N__->getName())); |
1730 | opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1731 | addTypeAttributes(opProto, N__, BatchedReduceAddNode::BatchIdx, /* isInput */ true); |
1732 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1733 | addTypeAttributes(opProto, N__, BatchedReduceAddNode::ResultIdx, /* isInput */ false); |
1734 | addValueAttribute(opProto, "Axis" , N__->getAxis()); |
1735 | if (N__->hasPredicate()) { |
1736 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1737 | } |
1738 | break; |
1739 | } |
1740 | |
1741 | case glow::Kinded::Kind::BatchedReduceSumSquareNodeKind: { |
1742 | auto *N__ = llvm::cast<BatchedReduceSumSquareNode>(node); |
1743 | opProto = graph.add_node(); |
1744 | opProto->set_op_type("Glow_BatchedReduceSumSquare" ); |
1745 | opProto->set_name(glow::legalizeName(N__->getName())); |
1746 | opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1747 | addTypeAttributes(opProto, N__, BatchedReduceSumSquareNode::BatchIdx, /* isInput */ true); |
1748 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1749 | addTypeAttributes(opProto, N__, BatchedReduceSumSquareNode::ResultIdx, /* isInput */ false); |
1750 | addValueAttribute(opProto, "Axis" , N__->getAxis()); |
1751 | if (N__->hasPredicate()) { |
1752 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1753 | } |
1754 | break; |
1755 | } |
1756 | |
1757 | case glow::Kinded::Kind::BatchedReduceMeanNodeKind: { |
1758 | auto *N__ = llvm::cast<BatchedReduceMeanNode>(node); |
1759 | opProto = graph.add_node(); |
1760 | opProto->set_op_type("Glow_BatchedReduceMean" ); |
1761 | opProto->set_name(glow::legalizeName(N__->getName())); |
1762 | opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1763 | addTypeAttributes(opProto, N__, BatchedReduceMeanNode::BatchIdx, /* isInput */ true); |
1764 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1765 | addTypeAttributes(opProto, N__, BatchedReduceMeanNode::ResultIdx, /* isInput */ false); |
1766 | addValueAttribute(opProto, "Axes" , N__->getAxes()); |
1767 | if (N__->hasPredicate()) { |
1768 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1769 | } |
1770 | break; |
1771 | } |
1772 | |
1773 | case glow::Kinded::Kind::BatchedReduceMinNodeKind: { |
1774 | auto *N__ = llvm::cast<BatchedReduceMinNode>(node); |
1775 | opProto = graph.add_node(); |
1776 | opProto->set_op_type("Glow_BatchedReduceMin" ); |
1777 | opProto->set_name(glow::legalizeName(N__->getName())); |
1778 | opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1779 | addTypeAttributes(opProto, N__, BatchedReduceMinNode::BatchIdx, /* isInput */ true); |
1780 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1781 | addTypeAttributes(opProto, N__, BatchedReduceMinNode::ResultIdx, /* isInput */ false); |
1782 | addValueAttribute(opProto, "Axes" , N__->getAxes()); |
1783 | if (N__->hasPredicate()) { |
1784 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1785 | } |
1786 | break; |
1787 | } |
1788 | |
1789 | case glow::Kinded::Kind::BatchedReduceMaxNodeKind: { |
1790 | auto *N__ = llvm::cast<BatchedReduceMaxNode>(node); |
1791 | opProto = graph.add_node(); |
1792 | opProto->set_op_type("Glow_BatchedReduceMax" ); |
1793 | opProto->set_name(glow::legalizeName(N__->getName())); |
1794 | opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1795 | addTypeAttributes(opProto, N__, BatchedReduceMaxNode::BatchIdx, /* isInput */ true); |
1796 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1797 | addTypeAttributes(opProto, N__, BatchedReduceMaxNode::ResultIdx, /* isInput */ false); |
1798 | addValueAttribute(opProto, "Axes" , N__->getAxes()); |
1799 | if (N__->hasPredicate()) { |
1800 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1801 | } |
1802 | break; |
1803 | } |
1804 | |
1805 | case glow::Kinded::Kind::BatchedReduceProdNodeKind: { |
1806 | auto *N__ = llvm::cast<BatchedReduceProdNode>(node); |
1807 | opProto = graph.add_node(); |
1808 | opProto->set_op_type("Glow_BatchedReduceProd" ); |
1809 | opProto->set_name(glow::legalizeName(N__->getName())); |
1810 | opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1811 | addTypeAttributes(opProto, N__, BatchedReduceProdNode::BatchIdx, /* isInput */ true); |
1812 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1813 | addTypeAttributes(opProto, N__, BatchedReduceProdNode::ResultIdx, /* isInput */ false); |
1814 | addValueAttribute(opProto, "Axis" , N__->getAxis()); |
1815 | if (N__->hasPredicate()) { |
1816 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1817 | } |
1818 | break; |
1819 | } |
1820 | |
1821 | case glow::Kinded::Kind::ChannelShuffleNodeKind: { |
1822 | auto *N__ = llvm::cast<ChannelShuffleNode>(node); |
1823 | opProto = graph.add_node(); |
1824 | opProto->set_op_type("Glow_ChannelShuffle" ); |
1825 | opProto->set_name(glow::legalizeName(N__->getName())); |
1826 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1827 | addTypeAttributes(opProto, N__, ChannelShuffleNode::InputIdx, /* isInput */ true); |
1828 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1829 | addTypeAttributes(opProto, N__, ChannelShuffleNode::ResultIdx, /* isInput */ false); |
1830 | addValueAttribute(opProto, "Group" , N__->getGroup()); |
1831 | addValueAttribute(opProto, "Kernel" , N__->getKernel()); |
1832 | if (N__->hasPredicate()) { |
1833 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1834 | } |
1835 | break; |
1836 | } |
1837 | |
1838 | case glow::Kinded::Kind::CumSumNodeKind: { |
1839 | auto *N__ = llvm::cast<CumSumNode>(node); |
1840 | opProto = graph.add_node(); |
1841 | opProto->set_op_type("Glow_CumSum" ); |
1842 | opProto->set_name(glow::legalizeName(N__->getName())); |
1843 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1844 | addTypeAttributes(opProto, N__, CumSumNode::InputIdx, /* isInput */ true); |
1845 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1846 | addTypeAttributes(opProto, N__, CumSumNode::ResultIdx, /* isInput */ false); |
1847 | addValueAttribute(opProto, "Dim" , N__->getDim()); |
1848 | addValueAttribute(opProto, "Exclusive" , N__->getExclusive()); |
1849 | addValueAttribute(opProto, "Reverse" , N__->getReverse()); |
1850 | if (N__->hasPredicate()) { |
1851 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1852 | } |
1853 | break; |
1854 | } |
1855 | |
1856 | case glow::Kinded::Kind::LengthsSumNodeKind: { |
1857 | auto *N__ = llvm::cast<LengthsSumNode>(node); |
1858 | opProto = graph.add_node(); |
1859 | opProto->set_op_type("Glow_LengthsSum" ); |
1860 | opProto->set_name(glow::legalizeName(N__->getName())); |
1861 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1862 | addTypeAttributes(opProto, N__, LengthsSumNode::DataIdx, /* isInput */ true); |
1863 | opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1864 | addTypeAttributes(opProto, N__, LengthsSumNode::LengthsIdx, /* isInput */ true); |
1865 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1866 | addTypeAttributes(opProto, N__, LengthsSumNode::ResultIdx, /* isInput */ false); |
1867 | if (N__->hasPredicate()) { |
1868 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1869 | } |
1870 | break; |
1871 | } |
1872 | |
1873 | case glow::Kinded::Kind::SparseLengthsSumGradNodeKind: { |
1874 | auto *N__ = llvm::cast<SparseLengthsSumGradNode>(node); |
1875 | opProto = graph.add_node(); |
1876 | opProto->set_op_type("Glow_SparseLengthsSumGrad" ); |
1877 | opProto->set_name(glow::legalizeName(N__->getName())); |
1878 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1879 | addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::DataIdx, /* isInput */ true); |
1880 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1881 | addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::IndicesIdx, /* isInput */ true); |
1882 | opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1883 | addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::LengthsIdx, /* isInput */ true); |
1884 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1885 | addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
1886 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1887 | addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
1888 | opProto->add_output(N__->getGradOfInputNamedData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1889 | addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::GradOfInputNamedDataIdx, /* isInput */ false); |
1890 | opProto->add_output(N__->getGradOfInputNamedIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1891 | addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::GradOfInputNamedIndicesIdx, /* isInput */ false); |
1892 | opProto->add_output(N__->getGradOfInputNamedLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1893 | addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::GradOfInputNamedLengthsIdx, /* isInput */ false); |
1894 | addValueAttribute(opProto, "LengthsMode" , N__->getLengthsMode()); |
1895 | addValueAttribute(opProto, "AvgLength" , N__->getAvgLength()); |
1896 | if (N__->hasPredicate()) { |
1897 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1898 | } |
1899 | break; |
1900 | } |
1901 | |
1902 | case glow::Kinded::Kind::SparseLengthsSumNodeKind: { |
1903 | auto *N__ = llvm::cast<SparseLengthsSumNode>(node); |
1904 | opProto = graph.add_node(); |
1905 | opProto->set_op_type("Glow_SparseLengthsSum" ); |
1906 | opProto->set_name(glow::legalizeName(N__->getName())); |
1907 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1908 | addTypeAttributes(opProto, N__, SparseLengthsSumNode::DataIdx, /* isInput */ true); |
1909 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1910 | addTypeAttributes(opProto, N__, SparseLengthsSumNode::IndicesIdx, /* isInput */ true); |
1911 | opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1912 | addTypeAttributes(opProto, N__, SparseLengthsSumNode::LengthsIdx, /* isInput */ true); |
1913 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1914 | addTypeAttributes(opProto, N__, SparseLengthsSumNode::ResultIdx, /* isInput */ false); |
1915 | addValueAttribute(opProto, "LengthsMode" , N__->getLengthsMode()); |
1916 | addValueAttribute(opProto, "AvgLength" , N__->getAvgLength()); |
1917 | if (N__->hasPredicate()) { |
1918 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1919 | } |
1920 | break; |
1921 | } |
1922 | |
1923 | case glow::Kinded::Kind::SparseLengthsWeightedSumGradNodeKind: { |
1924 | auto *N__ = llvm::cast<SparseLengthsWeightedSumGradNode>(node); |
1925 | opProto = graph.add_node(); |
1926 | opProto->set_op_type("Glow_SparseLengthsWeightedSumGrad" ); |
1927 | opProto->set_name(glow::legalizeName(N__->getName())); |
1928 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1929 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::DataIdx, /* isInput */ true); |
1930 | opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1931 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::WeightsIdx, /* isInput */ true); |
1932 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1933 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::IndicesIdx, /* isInput */ true); |
1934 | opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1935 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::LengthsIdx, /* isInput */ true); |
1936 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1937 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
1938 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1939 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
1940 | opProto->add_output(N__->getGradOfInputNamedData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1941 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::GradOfInputNamedDataIdx, /* isInput */ false); |
1942 | opProto->add_output(N__->getGradOfInputNamedWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1943 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::GradOfInputNamedWeightsIdx, /* isInput */ false); |
1944 | opProto->add_output(N__->getGradOfInputNamedIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1945 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::GradOfInputNamedIndicesIdx, /* isInput */ false); |
1946 | opProto->add_output(N__->getGradOfInputNamedLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1947 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::GradOfInputNamedLengthsIdx, /* isInput */ false); |
1948 | addValueAttribute(opProto, "LengthsMode" , N__->getLengthsMode()); |
1949 | addValueAttribute(opProto, "AvgLength" , N__->getAvgLength()); |
1950 | if (N__->hasPredicate()) { |
1951 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1952 | } |
1953 | break; |
1954 | } |
1955 | |
1956 | case glow::Kinded::Kind::SparseLengthsWeightedSumNodeKind: { |
1957 | auto *N__ = llvm::cast<SparseLengthsWeightedSumNode>(node); |
1958 | opProto = graph.add_node(); |
1959 | opProto->set_op_type("Glow_SparseLengthsWeightedSum" ); |
1960 | opProto->set_name(glow::legalizeName(N__->getName())); |
1961 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1962 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumNode::DataIdx, /* isInput */ true); |
1963 | opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1964 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumNode::WeightsIdx, /* isInput */ true); |
1965 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1966 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumNode::IndicesIdx, /* isInput */ true); |
1967 | opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1968 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumNode::LengthsIdx, /* isInput */ true); |
1969 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1970 | addTypeAttributes(opProto, N__, SparseLengthsWeightedSumNode::ResultIdx, /* isInput */ false); |
1971 | addValueAttribute(opProto, "LengthsMode" , N__->getLengthsMode()); |
1972 | addValueAttribute(opProto, "AvgLength" , N__->getAvgLength()); |
1973 | if (N__->hasPredicate()) { |
1974 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1975 | } |
1976 | break; |
1977 | } |
1978 | |
1979 | case glow::Kinded::Kind::EmbeddingNodeKind: { |
1980 | auto *N__ = llvm::cast<EmbeddingNode>(node); |
1981 | opProto = graph.add_node(); |
1982 | opProto->set_op_type("Glow_Embedding" ); |
1983 | opProto->set_name(glow::legalizeName(N__->getName())); |
1984 | opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1985 | addTypeAttributes(opProto, N__, EmbeddingNode::WeightsIdx, /* isInput */ true); |
1986 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1987 | addTypeAttributes(opProto, N__, EmbeddingNode::IndicesIdx, /* isInput */ true); |
1988 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1989 | addTypeAttributes(opProto, N__, EmbeddingNode::ResultIdx, /* isInput */ false); |
1990 | addValueAttribute(opProto, "PadIdx" , N__->getPadIdx()); |
1991 | addValueAttribute(opProto, "Scale" , N__->getScale()); |
1992 | addValueAttribute(opProto, "Sparse" , N__->getSparse()); |
1993 | if (N__->hasPredicate()) { |
1994 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
1995 | } |
1996 | break; |
1997 | } |
1998 | |
1999 | case glow::Kinded::Kind::EmbeddingBagNodeKind: { |
2000 | auto *N__ = llvm::cast<EmbeddingBagNode>(node); |
2001 | opProto = graph.add_node(); |
2002 | opProto->set_op_type("Glow_EmbeddingBag" ); |
2003 | opProto->set_name(glow::legalizeName(N__->getName())); |
2004 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2005 | addTypeAttributes(opProto, N__, EmbeddingBagNode::DataIdx, /* isInput */ true); |
2006 | opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2007 | addTypeAttributes(opProto, N__, EmbeddingBagNode::WeightsIdx, /* isInput */ true); |
2008 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2009 | addTypeAttributes(opProto, N__, EmbeddingBagNode::IndicesIdx, /* isInput */ true); |
2010 | opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2011 | addTypeAttributes(opProto, N__, EmbeddingBagNode::OffsetsIdx, /* isInput */ true); |
2012 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2013 | addTypeAttributes(opProto, N__, EmbeddingBagNode::ResultIdx, /* isInput */ false); |
2014 | addValueAttribute(opProto, "HasEndOffset" , N__->getHasEndOffset()); |
2015 | addValueAttribute(opProto, "LengthsMode" , N__->getLengthsMode()); |
2016 | addValueAttribute(opProto, "AvgLength" , N__->getAvgLength()); |
2017 | if (N__->hasPredicate()) { |
2018 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2019 | } |
2020 | break; |
2021 | } |
2022 | |
2023 | case glow::Kinded::Kind::EmbeddingBagByteRowwiseOffsetsNodeKind: { |
2024 | auto *N__ = llvm::cast<EmbeddingBagByteRowwiseOffsetsNode>(node); |
2025 | opProto = graph.add_node(); |
2026 | opProto->set_op_type("Glow_EmbeddingBagByteRowwiseOffsets" ); |
2027 | opProto->set_name(glow::legalizeName(N__->getName())); |
2028 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2029 | addTypeAttributes(opProto, N__, EmbeddingBagByteRowwiseOffsetsNode::DataIdx, /* isInput */ true); |
2030 | opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2031 | addTypeAttributes(opProto, N__, EmbeddingBagByteRowwiseOffsetsNode::WeightsIdx, /* isInput */ true); |
2032 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2033 | addTypeAttributes(opProto, N__, EmbeddingBagByteRowwiseOffsetsNode::IndicesIdx, /* isInput */ true); |
2034 | opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2035 | addTypeAttributes(opProto, N__, EmbeddingBagByteRowwiseOffsetsNode::OffsetsIdx, /* isInput */ true); |
2036 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2037 | addTypeAttributes(opProto, N__, EmbeddingBagByteRowwiseOffsetsNode::ResultIdx, /* isInput */ false); |
2038 | addValueAttribute(opProto, "UseFP16Accumulation" , N__->getUseFP16Accumulation()); |
2039 | addValueAttribute(opProto, "HasEndOffset" , N__->getHasEndOffset()); |
2040 | addValueAttribute(opProto, "LengthsMode" , N__->getLengthsMode()); |
2041 | addValueAttribute(opProto, "AvgLength" , N__->getAvgLength()); |
2042 | if (N__->hasPredicate()) { |
2043 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2044 | } |
2045 | break; |
2046 | } |
2047 | |
2048 | case glow::Kinded::Kind::RowwiseQuantizedSparseLengthsWeightedSumNodeKind: { |
2049 | auto *N__ = llvm::cast<RowwiseQuantizedSparseLengthsWeightedSumNode>(node); |
2050 | opProto = graph.add_node(); |
2051 | opProto->set_op_type("Glow_RowwiseQuantizedSparseLengthsWeightedSum" ); |
2052 | opProto->set_name(glow::legalizeName(N__->getName())); |
2053 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2054 | addTypeAttributes(opProto, N__, RowwiseQuantizedSparseLengthsWeightedSumNode::DataIdx, /* isInput */ true); |
2055 | opProto->add_input(N__->getScales().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2056 | addTypeAttributes(opProto, N__, RowwiseQuantizedSparseLengthsWeightedSumNode::ScalesIdx, /* isInput */ true); |
2057 | opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2058 | addTypeAttributes(opProto, N__, RowwiseQuantizedSparseLengthsWeightedSumNode::OffsetsIdx, /* isInput */ true); |
2059 | opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2060 | addTypeAttributes(opProto, N__, RowwiseQuantizedSparseLengthsWeightedSumNode::WeightsIdx, /* isInput */ true); |
2061 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2062 | addTypeAttributes(opProto, N__, RowwiseQuantizedSparseLengthsWeightedSumNode::IndicesIdx, /* isInput */ true); |
2063 | opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2064 | addTypeAttributes(opProto, N__, RowwiseQuantizedSparseLengthsWeightedSumNode::LengthsIdx, /* isInput */ true); |
2065 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2066 | addTypeAttributes(opProto, N__, RowwiseQuantizedSparseLengthsWeightedSumNode::ResultIdx, /* isInput */ false); |
2067 | addValueAttribute(opProto, "UseFP16Accumulation" , N__->getUseFP16Accumulation()); |
2068 | addValueAttribute(opProto, "LengthsMode" , N__->getLengthsMode()); |
2069 | addValueAttribute(opProto, "AvgLength" , N__->getAvgLength()); |
2070 | if (N__->hasPredicate()) { |
2071 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2072 | } |
2073 | break; |
2074 | } |
2075 | |
2076 | case glow::Kinded::Kind::FusedRowwiseQuantizedSparseLengthsWeightedSumNodeKind: { |
2077 | auto *N__ = llvm::cast<FusedRowwiseQuantizedSparseLengthsWeightedSumNode>(node); |
2078 | opProto = graph.add_node(); |
2079 | opProto->set_op_type("Glow_FusedRowwiseQuantizedSparseLengthsWeightedSum" ); |
2080 | opProto->set_name(glow::legalizeName(N__->getName())); |
2081 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2082 | addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsWeightedSumNode::DataIdx, /* isInput */ true); |
2083 | opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2084 | addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsWeightedSumNode::WeightsIdx, /* isInput */ true); |
2085 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2086 | addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsWeightedSumNode::IndicesIdx, /* isInput */ true); |
2087 | opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2088 | addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsWeightedSumNode::LengthsIdx, /* isInput */ true); |
2089 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2090 | addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsWeightedSumNode::ResultIdx, /* isInput */ false); |
2091 | addValueAttribute(opProto, "UseFP16Accumulation" , N__->getUseFP16Accumulation()); |
2092 | addValueAttribute(opProto, "LengthsMode" , N__->getLengthsMode()); |
2093 | addValueAttribute(opProto, "AvgLength" , N__->getAvgLength()); |
2094 | if (N__->hasPredicate()) { |
2095 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2096 | } |
2097 | break; |
2098 | } |
2099 | |
2100 | case glow::Kinded::Kind::FusedRowwiseQuantizedSparseLengthsSumNodeKind: { |
2101 | auto *N__ = llvm::cast<FusedRowwiseQuantizedSparseLengthsSumNode>(node); |
2102 | opProto = graph.add_node(); |
2103 | opProto->set_op_type("Glow_FusedRowwiseQuantizedSparseLengthsSum" ); |
2104 | opProto->set_name(glow::legalizeName(N__->getName())); |
2105 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2106 | addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsSumNode::DataIdx, /* isInput */ true); |
2107 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2108 | addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsSumNode::IndicesIdx, /* isInput */ true); |
2109 | opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2110 | addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsSumNode::LengthsIdx, /* isInput */ true); |
2111 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2112 | addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsSumNode::ResultIdx, /* isInput */ false); |
2113 | addValueAttribute(opProto, "UseFP16Accumulation" , N__->getUseFP16Accumulation()); |
2114 | addValueAttribute(opProto, "LengthsMode" , N__->getLengthsMode()); |
2115 | addValueAttribute(opProto, "AvgLength" , N__->getAvgLength()); |
2116 | if (N__->hasPredicate()) { |
2117 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2118 | } |
2119 | break; |
2120 | } |
2121 | |
2122 | case glow::Kinded::Kind::LengthsToRangesNodeKind: { |
2123 | auto *N__ = llvm::cast<LengthsToRangesNode>(node); |
2124 | opProto = graph.add_node(); |
2125 | opProto->set_op_type("Glow_LengthsToRanges" ); |
2126 | opProto->set_name(glow::legalizeName(N__->getName())); |
2127 | opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2128 | addTypeAttributes(opProto, N__, LengthsToRangesNode::LengthsIdx, /* isInput */ true); |
2129 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2130 | addTypeAttributes(opProto, N__, LengthsToRangesNode::ResultIdx, /* isInput */ false); |
2131 | if (N__->hasPredicate()) { |
2132 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2133 | } |
2134 | break; |
2135 | } |
2136 | |
2137 | case glow::Kinded::Kind::LengthsRangeFillNodeKind: { |
2138 | auto *N__ = llvm::cast<LengthsRangeFillNode>(node); |
2139 | opProto = graph.add_node(); |
2140 | opProto->set_op_type("Glow_LengthsRangeFill" ); |
2141 | opProto->set_name(glow::legalizeName(N__->getName())); |
2142 | opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2143 | addTypeAttributes(opProto, N__, LengthsRangeFillNode::LengthsIdx, /* isInput */ true); |
2144 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2145 | addTypeAttributes(opProto, N__, LengthsRangeFillNode::ResultIdx, /* isInput */ false); |
2146 | if (N__->hasPredicate()) { |
2147 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2148 | } |
2149 | break; |
2150 | } |
2151 | |
2152 | case glow::Kinded::Kind::BatchSparseToDenseNodeKind: { |
2153 | auto *N__ = llvm::cast<BatchSparseToDenseNode>(node); |
2154 | opProto = graph.add_node(); |
2155 | opProto->set_op_type("Glow_BatchSparseToDense" ); |
2156 | opProto->set_name(glow::legalizeName(N__->getName())); |
2157 | opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2158 | addTypeAttributes(opProto, N__, BatchSparseToDenseNode::LengthsIdx, /* isInput */ true); |
2159 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2160 | addTypeAttributes(opProto, N__, BatchSparseToDenseNode::IndicesIdx, /* isInput */ true); |
2161 | opProto->add_input(N__->getValues().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2162 | addTypeAttributes(opProto, N__, BatchSparseToDenseNode::ValuesIdx, /* isInput */ true); |
2163 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2164 | addTypeAttributes(opProto, N__, BatchSparseToDenseNode::ResultIdx, /* isInput */ false); |
2165 | addValueAttribute(opProto, "DefaultValue" , N__->getDefaultValue()); |
2166 | addValueAttribute(opProto, "DenseLastDim" , N__->getDenseLastDim()); |
2167 | if (N__->hasPredicate()) { |
2168 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2169 | } |
2170 | break; |
2171 | } |
2172 | |
2173 | case glow::Kinded::Kind::FillExamplesWithIndicatorNodeKind: { |
2174 | auto *N__ = llvm::cast<FillExamplesWithIndicatorNode>(node); |
2175 | opProto = graph.add_node(); |
2176 | opProto->set_op_type("Glow_FillExamplesWithIndicator" ); |
2177 | opProto->set_name(glow::legalizeName(N__->getName())); |
2178 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2179 | addTypeAttributes(opProto, N__, FillExamplesWithIndicatorNode::DataIdx, /* isInput */ true); |
2180 | opProto->add_input(N__->getIndicator().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2181 | addTypeAttributes(opProto, N__, FillExamplesWithIndicatorNode::IndicatorIdx, /* isInput */ true); |
2182 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2183 | addTypeAttributes(opProto, N__, FillExamplesWithIndicatorNode::ResultIdx, /* isInput */ false); |
2184 | if (N__->hasPredicate()) { |
2185 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2186 | } |
2187 | break; |
2188 | } |
2189 | |
2190 | case glow::Kinded::Kind::SparseToDenseMaskNodeKind: { |
2191 | auto *N__ = llvm::cast<SparseToDenseMaskNode>(node); |
2192 | opProto = graph.add_node(); |
2193 | opProto->set_op_type("Glow_SparseToDenseMask" ); |
2194 | opProto->set_name(glow::legalizeName(N__->getName())); |
2195 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2196 | addTypeAttributes(opProto, N__, SparseToDenseMaskNode::IndicesIdx, /* isInput */ true); |
2197 | opProto->add_input(N__->getValues().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2198 | addTypeAttributes(opProto, N__, SparseToDenseMaskNode::ValuesIdx, /* isInput */ true); |
2199 | opProto->add_input(N__->getDefaultValue().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2200 | addTypeAttributes(opProto, N__, SparseToDenseMaskNode::DefaultValueIdx, /* isInput */ true); |
2201 | opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2202 | addTypeAttributes(opProto, N__, SparseToDenseMaskNode::LengthsIdx, /* isInput */ true); |
2203 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2204 | addTypeAttributes(opProto, N__, SparseToDenseMaskNode::ResultIdx, /* isInput */ false); |
2205 | addValueAttribute(opProto, "Mask" , N__->getMask()); |
2206 | if (N__->hasPredicate()) { |
2207 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2208 | } |
2209 | break; |
2210 | } |
2211 | |
2212 | case glow::Kinded::Kind::IsNaNNodeKind: { |
2213 | auto *N__ = llvm::cast<IsNaNNode>(node); |
2214 | opProto = graph.add_node(); |
2215 | opProto->set_op_type("Glow_IsNaN" ); |
2216 | opProto->set_name(glow::legalizeName(N__->getName())); |
2217 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2218 | addTypeAttributes(opProto, N__, IsNaNNode::InputIdx, /* isInput */ true); |
2219 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2220 | addTypeAttributes(opProto, N__, IsNaNNode::ResultIdx, /* isInput */ false); |
2221 | if (N__->hasPredicate()) { |
2222 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2223 | } |
2224 | break; |
2225 | } |
2226 | |
2227 | case glow::Kinded::Kind::ReplaceNaNNodeKind: { |
2228 | auto *N__ = llvm::cast<ReplaceNaNNode>(node); |
2229 | opProto = graph.add_node(); |
2230 | opProto->set_op_type("Glow_ReplaceNaN" ); |
2231 | opProto->set_name(glow::legalizeName(N__->getName())); |
2232 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2233 | addTypeAttributes(opProto, N__, ReplaceNaNNode::InputIdx, /* isInput */ true); |
2234 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2235 | addTypeAttributes(opProto, N__, ReplaceNaNNode::ResultIdx, /* isInput */ false); |
2236 | addValueAttribute(opProto, "Value" , N__->getValue()); |
2237 | if (N__->hasPredicate()) { |
2238 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2239 | } |
2240 | break; |
2241 | } |
2242 | |
2243 | case glow::Kinded::Kind::ModuloNodeKind: { |
2244 | auto *N__ = llvm::cast<ModuloNode>(node); |
2245 | opProto = graph.add_node(); |
2246 | opProto->set_op_type("Glow_Modulo" ); |
2247 | opProto->set_name(glow::legalizeName(N__->getName())); |
2248 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2249 | addTypeAttributes(opProto, N__, ModuloNode::InputIdx, /* isInput */ true); |
2250 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2251 | addTypeAttributes(opProto, N__, ModuloNode::ResultIdx, /* isInput */ false); |
2252 | addValueAttribute(opProto, "Divisor" , N__->getDivisor()); |
2253 | addValueAttribute(opProto, "SignFollowDivisor" , N__->getSignFollowDivisor()); |
2254 | if (N__->hasPredicate()) { |
2255 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2256 | } |
2257 | break; |
2258 | } |
2259 | |
2260 | case glow::Kinded::Kind::BatchedPairwiseDotProductNodeKind: { |
2261 | auto *N__ = llvm::cast<BatchedPairwiseDotProductNode>(node); |
2262 | opProto = graph.add_node(); |
2263 | opProto->set_op_type("Glow_BatchedPairwiseDotProduct" ); |
2264 | opProto->set_name(glow::legalizeName(N__->getName())); |
2265 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2266 | addTypeAttributes(opProto, N__, BatchedPairwiseDotProductNode::ResultIdx, /* isInput */ false); |
2267 | addValueAttribute(opProto, "Inputs" , N__->getInputs()); |
2268 | for (unsigned i = 0, e = N__->getInputs().size(); i < e; i++) { |
2269 | addTypeAttributes(opProto, N__->getInputs()[i], i, /* isInput */ true, "Inputs_" ); |
2270 | } |
2271 | if (N__->hasPredicate()) { |
2272 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2273 | } |
2274 | break; |
2275 | } |
2276 | |
2277 | case glow::Kinded::Kind::BatchedPairwiseDotProductGradNodeKind: { |
2278 | auto *N__ = llvm::cast<BatchedPairwiseDotProductGradNode>(node); |
2279 | opProto = graph.add_node(); |
2280 | opProto->set_op_type("Glow_BatchedPairwiseDotProductGrad" ); |
2281 | opProto->set_name(glow::legalizeName(N__->getName())); |
2282 | opProto->add_input(N__->getOutputGrad().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2283 | addTypeAttributes(opProto, N__, BatchedPairwiseDotProductGradNode::OutputGradIdx, /* isInput */ true); |
2284 | addValueAttribute(opProto, "OriginalInputs" , N__->getOriginalInputs()); |
2285 | for (unsigned i = 0, e = N__->getOriginalInputs().size(); i < e; i++) { |
2286 | addTypeAttributes(opProto, N__->getOriginalInputs()[i], i, /* isInput */ true, "OriginalInputs_" ); |
2287 | } |
2288 | if (N__->hasPredicate()) { |
2289 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2290 | } |
2291 | break; |
2292 | } |
2293 | |
2294 | case glow::Kinded::Kind::BatchedUnaryEmbeddingsBagsNodeKind: { |
2295 | auto *N__ = llvm::cast<BatchedUnaryEmbeddingsBagsNode>(node); |
2296 | opProto = graph.add_node(); |
2297 | opProto->set_op_type("Glow_BatchedUnaryEmbeddingsBags" ); |
2298 | opProto->set_name(glow::legalizeName(N__->getName())); |
2299 | opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2300 | addTypeAttributes(opProto, N__, BatchedUnaryEmbeddingsBagsNode::WeightsIdx, /* isInput */ true); |
2301 | opProto->add_input(N__->getTableOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2302 | addTypeAttributes(opProto, N__, BatchedUnaryEmbeddingsBagsNode::TableOffsetsIdx, /* isInput */ true); |
2303 | opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2304 | addTypeAttributes(opProto, N__, BatchedUnaryEmbeddingsBagsNode::OffsetsIdx, /* isInput */ true); |
2305 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2306 | addTypeAttributes(opProto, N__, BatchedUnaryEmbeddingsBagsNode::IndicesIdx, /* isInput */ true); |
2307 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2308 | addTypeAttributes(opProto, N__, BatchedUnaryEmbeddingsBagsNode::ResultIdx, /* isInput */ false); |
2309 | if (N__->hasPredicate()) { |
2310 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2311 | } |
2312 | break; |
2313 | } |
2314 | |
2315 | case glow::Kinded::Kind::IntNBitSplitEmbeddingBagsNodeKind: { |
2316 | auto *N__ = llvm::cast<IntNBitSplitEmbeddingBagsNode>(node); |
2317 | opProto = graph.add_node(); |
2318 | opProto->set_op_type("Glow_IntNBitSplitEmbeddingBags" ); |
2319 | opProto->set_name(glow::legalizeName(N__->getName())); |
2320 | opProto->add_input(N__->getDevWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2321 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::DevWeightsIdx, /* isInput */ true); |
2322 | opProto->add_input(N__->getUvmWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2323 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::UvmWeightsIdx, /* isInput */ true); |
2324 | opProto->add_input(N__->getWeightsPlacements().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2325 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::WeightsPlacementsIdx, /* isInput */ true); |
2326 | opProto->add_input(N__->getWeightsOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2327 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::WeightsOffsetsIdx, /* isInput */ true); |
2328 | opProto->add_input(N__->getWeightsTys().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2329 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::WeightsTysIdx, /* isInput */ true); |
2330 | opProto->add_input(N__->getDimOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2331 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::DimOffsetsIdx, /* isInput */ true); |
2332 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2333 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::IndicesIdx, /* isInput */ true); |
2334 | opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2335 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::OffsetsIdx, /* isInput */ true); |
2336 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2337 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::ResultIdx, /* isInput */ false); |
2338 | addValueAttribute(opProto, "TotalDims" , N__->getTotalDims()); |
2339 | addValueAttribute(opProto, "PoolingMode" , N__->getPoolingMode()); |
2340 | addValueAttribute(opProto, "OutputDType" , N__->getOutputDType()); |
2341 | if (N__->hasPredicate()) { |
2342 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2343 | } |
2344 | break; |
2345 | } |
2346 | |
2347 | case glow::Kinded::Kind::IntNBitSplitEmbeddingWeightedBagsNodeKind: { |
2348 | auto *N__ = llvm::cast<IntNBitSplitEmbeddingWeightedBagsNode>(node); |
2349 | opProto = graph.add_node(); |
2350 | opProto->set_op_type("Glow_IntNBitSplitEmbeddingWeightedBags" ); |
2351 | opProto->set_name(glow::legalizeName(N__->getName())); |
2352 | opProto->add_input(N__->getDevWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2353 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::DevWeightsIdx, /* isInput */ true); |
2354 | opProto->add_input(N__->getUvmWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2355 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::UvmWeightsIdx, /* isInput */ true); |
2356 | opProto->add_input(N__->getWeightsPlacements().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2357 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::WeightsPlacementsIdx, /* isInput */ true); |
2358 | opProto->add_input(N__->getWeightsOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2359 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::WeightsOffsetsIdx, /* isInput */ true); |
2360 | opProto->add_input(N__->getWeightsTys().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2361 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::WeightsTysIdx, /* isInput */ true); |
2362 | opProto->add_input(N__->getDimOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2363 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::DimOffsetsIdx, /* isInput */ true); |
2364 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2365 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::IndicesIdx, /* isInput */ true); |
2366 | opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2367 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::OffsetsIdx, /* isInput */ true); |
2368 | opProto->add_input(N__->getIndiceWeight().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2369 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::IndiceWeightIdx, /* isInput */ true); |
2370 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2371 | addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::ResultIdx, /* isInput */ false); |
2372 | addValueAttribute(opProto, "TotalDims" , N__->getTotalDims()); |
2373 | addValueAttribute(opProto, "PoolingMode" , N__->getPoolingMode()); |
2374 | addValueAttribute(opProto, "OutputDType" , N__->getOutputDType()); |
2375 | if (N__->hasPredicate()) { |
2376 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2377 | } |
2378 | break; |
2379 | } |
2380 | |
2381 | case glow::Kinded::Kind::GaussianFillNodeKind: { |
2382 | auto *N__ = llvm::cast<GaussianFillNode>(node); |
2383 | opProto = graph.add_node(); |
2384 | opProto->set_op_type("Glow_GaussianFill" ); |
2385 | opProto->set_name(glow::legalizeName(N__->getName())); |
2386 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2387 | addTypeAttributes(opProto, N__, GaussianFillNode::InputIdx, /* isInput */ true); |
2388 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2389 | addTypeAttributes(opProto, N__, GaussianFillNode::ResultIdx, /* isInput */ false); |
2390 | addValueAttribute(opProto, "Mean" , N__->getMean()); |
2391 | addValueAttribute(opProto, "Scale" , N__->getScale()); |
2392 | addValueAttribute(opProto, "Seed" , N__->getSeed()); |
2393 | if (N__->hasPredicate()) { |
2394 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2395 | } |
2396 | break; |
2397 | } |
2398 | |
2399 | case glow::Kinded::Kind::ReluGradNodeKind: { |
2400 | auto *N__ = llvm::cast<ReluGradNode>(node); |
2401 | opProto = graph.add_node(); |
2402 | opProto->set_op_type("Glow_ReluGrad" ); |
2403 | opProto->set_name(glow::legalizeName(N__->getName())); |
2404 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2405 | addTypeAttributes(opProto, N__, ReluGradNode::InputIdx, /* isInput */ true); |
2406 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2407 | addTypeAttributes(opProto, N__, ReluGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
2408 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2409 | addTypeAttributes(opProto, N__, ReluGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
2410 | opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2411 | addTypeAttributes(opProto, N__, ReluGradNode::GradOfInputNamedInputIdx, /* isInput */ false); |
2412 | if (N__->hasPredicate()) { |
2413 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2414 | } |
2415 | break; |
2416 | } |
2417 | |
2418 | case glow::Kinded::Kind::ReluNodeKind: { |
2419 | auto *N__ = llvm::cast<ReluNode>(node); |
2420 | opProto = graph.add_node(); |
2421 | opProto->set_op_type("Glow_Relu" ); |
2422 | opProto->set_name(glow::legalizeName(N__->getName())); |
2423 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2424 | addTypeAttributes(opProto, N__, ReluNode::InputIdx, /* isInput */ true); |
2425 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2426 | addTypeAttributes(opProto, N__, ReluNode::ResultIdx, /* isInput */ false); |
2427 | if (N__->hasPredicate()) { |
2428 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2429 | } |
2430 | break; |
2431 | } |
2432 | |
2433 | case glow::Kinded::Kind::HardSwishNodeKind: { |
2434 | auto *N__ = llvm::cast<HardSwishNode>(node); |
2435 | opProto = graph.add_node(); |
2436 | opProto->set_op_type("Glow_HardSwish" ); |
2437 | opProto->set_name(glow::legalizeName(N__->getName())); |
2438 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2439 | addTypeAttributes(opProto, N__, HardSwishNode::InputIdx, /* isInput */ true); |
2440 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2441 | addTypeAttributes(opProto, N__, HardSwishNode::ResultIdx, /* isInput */ false); |
2442 | if (N__->hasPredicate()) { |
2443 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2444 | } |
2445 | break; |
2446 | } |
2447 | |
2448 | case glow::Kinded::Kind::GeluNodeKind: { |
2449 | auto *N__ = llvm::cast<GeluNode>(node); |
2450 | opProto = graph.add_node(); |
2451 | opProto->set_op_type("Glow_Gelu" ); |
2452 | opProto->set_name(glow::legalizeName(N__->getName())); |
2453 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2454 | addTypeAttributes(opProto, N__, GeluNode::InputIdx, /* isInput */ true); |
2455 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2456 | addTypeAttributes(opProto, N__, GeluNode::ResultIdx, /* isInput */ false); |
2457 | if (N__->hasPredicate()) { |
2458 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2459 | } |
2460 | break; |
2461 | } |
2462 | |
2463 | case glow::Kinded::Kind::ClipNodeKind: { |
2464 | auto *N__ = llvm::cast<ClipNode>(node); |
2465 | opProto = graph.add_node(); |
2466 | opProto->set_op_type("Glow_Clip" ); |
2467 | opProto->set_name(glow::legalizeName(N__->getName())); |
2468 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2469 | addTypeAttributes(opProto, N__, ClipNode::InputIdx, /* isInput */ true); |
2470 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2471 | addTypeAttributes(opProto, N__, ClipNode::ResultIdx, /* isInput */ false); |
2472 | addValueAttribute(opProto, "Min" , N__->getMin()); |
2473 | addValueAttribute(opProto, "Max" , N__->getMax()); |
2474 | if (N__->hasPredicate()) { |
2475 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2476 | } |
2477 | break; |
2478 | } |
2479 | |
2480 | case glow::Kinded::Kind::PReluNodeKind: { |
2481 | auto *N__ = llvm::cast<PReluNode>(node); |
2482 | opProto = graph.add_node(); |
2483 | opProto->set_op_type("Glow_PRelu" ); |
2484 | opProto->set_name(glow::legalizeName(N__->getName())); |
2485 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2486 | addTypeAttributes(opProto, N__, PReluNode::InputIdx, /* isInput */ true); |
2487 | opProto->add_input(N__->getSlope().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2488 | addTypeAttributes(opProto, N__, PReluNode::SlopeIdx, /* isInput */ true); |
2489 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2490 | addTypeAttributes(opProto, N__, PReluNode::ResultIdx, /* isInput */ false); |
2491 | if (N__->hasPredicate()) { |
2492 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2493 | } |
2494 | break; |
2495 | } |
2496 | |
2497 | case glow::Kinded::Kind::SigmoidGradNodeKind: { |
2498 | auto *N__ = llvm::cast<SigmoidGradNode>(node); |
2499 | opProto = graph.add_node(); |
2500 | opProto->set_op_type("Glow_SigmoidGrad" ); |
2501 | opProto->set_name(glow::legalizeName(N__->getName())); |
2502 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2503 | addTypeAttributes(opProto, N__, SigmoidGradNode::InputIdx, /* isInput */ true); |
2504 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2505 | addTypeAttributes(opProto, N__, SigmoidGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
2506 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2507 | addTypeAttributes(opProto, N__, SigmoidGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
2508 | opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2509 | addTypeAttributes(opProto, N__, SigmoidGradNode::GradOfInputNamedInputIdx, /* isInput */ false); |
2510 | if (N__->hasPredicate()) { |
2511 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2512 | } |
2513 | break; |
2514 | } |
2515 | |
2516 | case glow::Kinded::Kind::SigmoidNodeKind: { |
2517 | auto *N__ = llvm::cast<SigmoidNode>(node); |
2518 | opProto = graph.add_node(); |
2519 | opProto->set_op_type("Glow_Sigmoid" ); |
2520 | opProto->set_name(glow::legalizeName(N__->getName())); |
2521 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2522 | addTypeAttributes(opProto, N__, SigmoidNode::InputIdx, /* isInput */ true); |
2523 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2524 | addTypeAttributes(opProto, N__, SigmoidNode::ResultIdx, /* isInput */ false); |
2525 | if (N__->hasPredicate()) { |
2526 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2527 | } |
2528 | break; |
2529 | } |
2530 | |
2531 | case glow::Kinded::Kind::SwishNodeKind: { |
2532 | auto *N__ = llvm::cast<SwishNode>(node); |
2533 | opProto = graph.add_node(); |
2534 | opProto->set_op_type("Glow_Swish" ); |
2535 | opProto->set_name(glow::legalizeName(N__->getName())); |
2536 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2537 | addTypeAttributes(opProto, N__, SwishNode::InputIdx, /* isInput */ true); |
2538 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2539 | addTypeAttributes(opProto, N__, SwishNode::ResultIdx, /* isInput */ false); |
2540 | if (N__->hasPredicate()) { |
2541 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2542 | } |
2543 | break; |
2544 | } |
2545 | |
2546 | case glow::Kinded::Kind::TanhGradNodeKind: { |
2547 | auto *N__ = llvm::cast<TanhGradNode>(node); |
2548 | opProto = graph.add_node(); |
2549 | opProto->set_op_type("Glow_TanhGrad" ); |
2550 | opProto->set_name(glow::legalizeName(N__->getName())); |
2551 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2552 | addTypeAttributes(opProto, N__, TanhGradNode::InputIdx, /* isInput */ true); |
2553 | opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2554 | addTypeAttributes(opProto, N__, TanhGradNode::OriginalOutputForResultIdx, /* isInput */ true); |
2555 | opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2556 | addTypeAttributes(opProto, N__, TanhGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true); |
2557 | opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2558 | addTypeAttributes(opProto, N__, TanhGradNode::GradOfInputNamedInputIdx, /* isInput */ false); |
2559 | if (N__->hasPredicate()) { |
2560 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2561 | } |
2562 | break; |
2563 | } |
2564 | |
2565 | case glow::Kinded::Kind::TanhNodeKind: { |
2566 | auto *N__ = llvm::cast<TanhNode>(node); |
2567 | opProto = graph.add_node(); |
2568 | opProto->set_op_type("Glow_Tanh" ); |
2569 | opProto->set_name(glow::legalizeName(N__->getName())); |
2570 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2571 | addTypeAttributes(opProto, N__, TanhNode::InputIdx, /* isInput */ true); |
2572 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2573 | addTypeAttributes(opProto, N__, TanhNode::ResultIdx, /* isInput */ false); |
2574 | if (N__->hasPredicate()) { |
2575 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2576 | } |
2577 | break; |
2578 | } |
2579 | |
2580 | case glow::Kinded::Kind::LeakyReluNodeKind: { |
2581 | auto *N__ = llvm::cast<LeakyReluNode>(node); |
2582 | opProto = graph.add_node(); |
2583 | opProto->set_op_type("Glow_LeakyRelu" ); |
2584 | opProto->set_name(glow::legalizeName(N__->getName())); |
2585 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2586 | addTypeAttributes(opProto, N__, LeakyReluNode::InputIdx, /* isInput */ true); |
2587 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2588 | addTypeAttributes(opProto, N__, LeakyReluNode::ResultIdx, /* isInput */ false); |
2589 | addValueAttribute(opProto, "Alpha" , N__->getAlpha()); |
2590 | if (N__->hasPredicate()) { |
2591 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2592 | } |
2593 | break; |
2594 | } |
2595 | |
2596 | case glow::Kinded::Kind::SoftPlusNodeKind: { |
2597 | auto *N__ = llvm::cast<SoftPlusNode>(node); |
2598 | opProto = graph.add_node(); |
2599 | opProto->set_op_type("Glow_SoftPlus" ); |
2600 | opProto->set_name(glow::legalizeName(N__->getName())); |
2601 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2602 | addTypeAttributes(opProto, N__, SoftPlusNode::InputIdx, /* isInput */ true); |
2603 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2604 | addTypeAttributes(opProto, N__, SoftPlusNode::ResultIdx, /* isInput */ false); |
2605 | if (N__->hasPredicate()) { |
2606 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2607 | } |
2608 | break; |
2609 | } |
2610 | |
2611 | case glow::Kinded::Kind::ReshapeNodeKind: { |
2612 | auto *N__ = llvm::cast<ReshapeNode>(node); |
2613 | opProto = graph.add_node(); |
2614 | opProto->set_op_type("Glow_Reshape" ); |
2615 | opProto->set_name(glow::legalizeName(N__->getName())); |
2616 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2617 | addTypeAttributes(opProto, N__, ReshapeNode::InputIdx, /* isInput */ true); |
2618 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2619 | addTypeAttributes(opProto, N__, ReshapeNode::ResultIdx, /* isInput */ false); |
2620 | addValueAttribute(opProto, "Dims" , N__->getDims()); |
2621 | addValueAttribute(opProto, "Layout" , N__->getLayout()); |
2622 | if (N__->hasPredicate()) { |
2623 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2624 | } |
2625 | break; |
2626 | } |
2627 | |
2628 | case glow::Kinded::Kind::TransposeNodeKind: { |
2629 | auto *N__ = llvm::cast<TransposeNode>(node); |
2630 | opProto = graph.add_node(); |
2631 | opProto->set_op_type("Glow_Transpose" ); |
2632 | opProto->set_name(glow::legalizeName(N__->getName())); |
2633 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2634 | addTypeAttributes(opProto, N__, TransposeNode::InputIdx, /* isInput */ true); |
2635 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2636 | addTypeAttributes(opProto, N__, TransposeNode::ResultIdx, /* isInput */ false); |
2637 | addValueAttribute(opProto, "Shuffle" , N__->getShuffle()); |
2638 | addValueAttribute(opProto, "Layout" , N__->getLayout()); |
2639 | if (N__->hasPredicate()) { |
2640 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2641 | } |
2642 | break; |
2643 | } |
2644 | |
2645 | case glow::Kinded::Kind::ConcatNodeKind: { |
2646 | auto *N__ = llvm::cast<ConcatNode>(node); |
2647 | opProto = graph.add_node(); |
2648 | opProto->set_op_type("Glow_Concat" ); |
2649 | opProto->set_name(glow::legalizeName(N__->getName())); |
2650 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2651 | addTypeAttributes(opProto, N__, ConcatNode::ResultIdx, /* isInput */ false); |
2652 | addValueAttribute(opProto, "Inputs" , N__->getInputs()); |
2653 | for (unsigned i = 0, e = N__->getInputs().size(); i < e; i++) { |
2654 | addTypeAttributes(opProto, N__->getInputs()[i], i, /* isInput */ true, "Inputs_" ); |
2655 | } |
2656 | addValueAttribute(opProto, "Dim" , N__->getDim()); |
2657 | if (N__->hasPredicate()) { |
2658 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2659 | } |
2660 | break; |
2661 | } |
2662 | |
2663 | case glow::Kinded::Kind::SliceNodeKind: { |
2664 | auto *N__ = llvm::cast<SliceNode>(node); |
2665 | opProto = graph.add_node(); |
2666 | opProto->set_op_type("Glow_Slice" ); |
2667 | opProto->set_name(glow::legalizeName(N__->getName())); |
2668 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2669 | addTypeAttributes(opProto, N__, SliceNode::InputIdx, /* isInput */ true); |
2670 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2671 | addTypeAttributes(opProto, N__, SliceNode::ResultIdx, /* isInput */ false); |
2672 | addValueAttribute(opProto, "Start" , N__->getStart()); |
2673 | if (N__->hasPredicate()) { |
2674 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2675 | } |
2676 | break; |
2677 | } |
2678 | |
2679 | case glow::Kinded::Kind::InsertTensorNodeKind: { |
2680 | auto *N__ = llvm::cast<InsertTensorNode>(node); |
2681 | opProto = graph.add_node(); |
2682 | opProto->set_op_type("Glow_InsertTensor" ); |
2683 | opProto->set_name(glow::legalizeName(N__->getName())); |
2684 | opProto->add_input(N__->getBig().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2685 | addTypeAttributes(opProto, N__, InsertTensorNode::BigIdx, /* isInput */ true); |
2686 | opProto->add_input(N__->getSmall().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2687 | addTypeAttributes(opProto, N__, InsertTensorNode::SmallIdx, /* isInput */ true); |
2688 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2689 | addTypeAttributes(opProto, N__, InsertTensorNode::ResultIdx, /* isInput */ false); |
2690 | addValueAttribute(opProto, "Start" , N__->getStart()); |
2691 | addValueAttribute(opProto, "Count" , N__->getCount()); |
2692 | addValueAttribute(opProto, "Axis" , N__->getAxis()); |
2693 | if (N__->hasPredicate()) { |
2694 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2695 | } |
2696 | break; |
2697 | } |
2698 | |
2699 | case glow::Kinded::Kind::GatherNodeKind: { |
2700 | auto *N__ = llvm::cast<GatherNode>(node); |
2701 | opProto = graph.add_node(); |
2702 | opProto->set_op_type("Glow_Gather" ); |
2703 | opProto->set_name(glow::legalizeName(N__->getName())); |
2704 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2705 | addTypeAttributes(opProto, N__, GatherNode::DataIdx, /* isInput */ true); |
2706 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2707 | addTypeAttributes(opProto, N__, GatherNode::IndicesIdx, /* isInput */ true); |
2708 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2709 | addTypeAttributes(opProto, N__, GatherNode::ResultIdx, /* isInput */ false); |
2710 | addValueAttribute(opProto, "BatchDims" , N__->getBatchDims()); |
2711 | if (N__->hasPredicate()) { |
2712 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2713 | } |
2714 | break; |
2715 | } |
2716 | |
2717 | case glow::Kinded::Kind::GatherNDNodeKind: { |
2718 | auto *N__ = llvm::cast<GatherNDNode>(node); |
2719 | opProto = graph.add_node(); |
2720 | opProto->set_op_type("Glow_GatherND" ); |
2721 | opProto->set_name(glow::legalizeName(N__->getName())); |
2722 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2723 | addTypeAttributes(opProto, N__, GatherNDNode::DataIdx, /* isInput */ true); |
2724 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2725 | addTypeAttributes(opProto, N__, GatherNDNode::IndicesIdx, /* isInput */ true); |
2726 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2727 | addTypeAttributes(opProto, N__, GatherNDNode::ResultIdx, /* isInput */ false); |
2728 | addValueAttribute(opProto, "BatchDims" , N__->getBatchDims()); |
2729 | if (N__->hasPredicate()) { |
2730 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2731 | } |
2732 | break; |
2733 | } |
2734 | |
2735 | case glow::Kinded::Kind::GatherElementsNodeKind: { |
2736 | auto *N__ = llvm::cast<GatherElementsNode>(node); |
2737 | opProto = graph.add_node(); |
2738 | opProto->set_op_type("Glow_GatherElements" ); |
2739 | opProto->set_name(glow::legalizeName(N__->getName())); |
2740 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2741 | addTypeAttributes(opProto, N__, GatherElementsNode::DataIdx, /* isInput */ true); |
2742 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2743 | addTypeAttributes(opProto, N__, GatherElementsNode::IndicesIdx, /* isInput */ true); |
2744 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2745 | addTypeAttributes(opProto, N__, GatherElementsNode::ResultIdx, /* isInput */ false); |
2746 | addValueAttribute(opProto, "Dim" , N__->getDim()); |
2747 | if (N__->hasPredicate()) { |
2748 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2749 | } |
2750 | break; |
2751 | } |
2752 | |
2753 | case glow::Kinded::Kind::GatherRangesNodeKind: { |
2754 | auto *N__ = llvm::cast<GatherRangesNode>(node); |
2755 | opProto = graph.add_node(); |
2756 | opProto->set_op_type("Glow_GatherRanges" ); |
2757 | opProto->set_name(glow::legalizeName(N__->getName())); |
2758 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2759 | addTypeAttributes(opProto, N__, GatherRangesNode::DataIdx, /* isInput */ true); |
2760 | opProto->add_input(N__->getRanges().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2761 | addTypeAttributes(opProto, N__, GatherRangesNode::RangesIdx, /* isInput */ true); |
2762 | opProto->add_output(N__->getOutput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2763 | addTypeAttributes(opProto, N__, GatherRangesNode::OutputIdx, /* isInput */ false); |
2764 | opProto->add_output(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2765 | addTypeAttributes(opProto, N__, GatherRangesNode::LengthsIdx, /* isInput */ false); |
2766 | if (N__->hasPredicate()) { |
2767 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2768 | } |
2769 | break; |
2770 | } |
2771 | |
2772 | case glow::Kinded::Kind::ScatterDataNodeKind: { |
2773 | auto *N__ = llvm::cast<ScatterDataNode>(node); |
2774 | opProto = graph.add_node(); |
2775 | opProto->set_op_type("Glow_ScatterData" ); |
2776 | opProto->set_name(glow::legalizeName(N__->getName())); |
2777 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2778 | addTypeAttributes(opProto, N__, ScatterDataNode::DataIdx, /* isInput */ true); |
2779 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2780 | addTypeAttributes(opProto, N__, ScatterDataNode::IndicesIdx, /* isInput */ true); |
2781 | opProto->add_input(N__->getSlices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2782 | addTypeAttributes(opProto, N__, ScatterDataNode::SlicesIdx, /* isInput */ true); |
2783 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2784 | addTypeAttributes(opProto, N__, ScatterDataNode::ResultIdx, /* isInput */ false); |
2785 | addValueAttribute(opProto, "Cumulative" , N__->getCumulative()); |
2786 | if (N__->hasPredicate()) { |
2787 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2788 | } |
2789 | break; |
2790 | } |
2791 | |
2792 | case glow::Kinded::Kind::TileNodeKind: { |
2793 | auto *N__ = llvm::cast<TileNode>(node); |
2794 | opProto = graph.add_node(); |
2795 | opProto->set_op_type("Glow_Tile" ); |
2796 | opProto->set_name(glow::legalizeName(N__->getName())); |
2797 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2798 | addTypeAttributes(opProto, N__, TileNode::InputIdx, /* isInput */ true); |
2799 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2800 | addTypeAttributes(opProto, N__, TileNode::ResultIdx, /* isInput */ false); |
2801 | addValueAttribute(opProto, "Count" , N__->getCount()); |
2802 | addValueAttribute(opProto, "Axis" , N__->getAxis()); |
2803 | if (N__->hasPredicate()) { |
2804 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2805 | } |
2806 | break; |
2807 | } |
2808 | |
2809 | case glow::Kinded::Kind::BatchOneHotNodeKind: { |
2810 | auto *N__ = llvm::cast<BatchOneHotNode>(node); |
2811 | opProto = graph.add_node(); |
2812 | opProto->set_op_type("Glow_BatchOneHot" ); |
2813 | opProto->set_name(glow::legalizeName(N__->getName())); |
2814 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2815 | addTypeAttributes(opProto, N__, BatchOneHotNode::DataIdx, /* isInput */ true); |
2816 | opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2817 | addTypeAttributes(opProto, N__, BatchOneHotNode::LengthsIdx, /* isInput */ true); |
2818 | opProto->add_input(N__->getValues().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2819 | addTypeAttributes(opProto, N__, BatchOneHotNode::ValuesIdx, /* isInput */ true); |
2820 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2821 | addTypeAttributes(opProto, N__, BatchOneHotNode::ResultIdx, /* isInput */ false); |
2822 | if (N__->hasPredicate()) { |
2823 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2824 | } |
2825 | break; |
2826 | } |
2827 | |
2828 | case glow::Kinded::Kind::SpaceToDepthNodeKind: { |
2829 | auto *N__ = llvm::cast<SpaceToDepthNode>(node); |
2830 | opProto = graph.add_node(); |
2831 | opProto->set_op_type("Glow_SpaceToDepth" ); |
2832 | opProto->set_name(glow::legalizeName(N__->getName())); |
2833 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2834 | addTypeAttributes(opProto, N__, SpaceToDepthNode::InputIdx, /* isInput */ true); |
2835 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2836 | addTypeAttributes(opProto, N__, SpaceToDepthNode::ResultIdx, /* isInput */ false); |
2837 | addValueAttribute(opProto, "BlockSize" , N__->getBlockSize()); |
2838 | if (N__->hasPredicate()) { |
2839 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2840 | } |
2841 | break; |
2842 | } |
2843 | |
2844 | case glow::Kinded::Kind::ResizeNearestNodeKind: { |
2845 | auto *N__ = llvm::cast<ResizeNearestNode>(node); |
2846 | opProto = graph.add_node(); |
2847 | opProto->set_op_type("Glow_ResizeNearest" ); |
2848 | opProto->set_name(glow::legalizeName(N__->getName())); |
2849 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2850 | addTypeAttributes(opProto, N__, ResizeNearestNode::InputIdx, /* isInput */ true); |
2851 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2852 | addTypeAttributes(opProto, N__, ResizeNearestNode::ResultIdx, /* isInput */ false); |
2853 | addValueAttribute(opProto, "Scale" , N__->getScale()); |
2854 | if (N__->hasPredicate()) { |
2855 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2856 | } |
2857 | break; |
2858 | } |
2859 | |
2860 | case glow::Kinded::Kind::ResizeBilinearNodeKind: { |
2861 | auto *N__ = llvm::cast<ResizeBilinearNode>(node); |
2862 | opProto = graph.add_node(); |
2863 | opProto->set_op_type("Glow_ResizeBilinear" ); |
2864 | opProto->set_name(glow::legalizeName(N__->getName())); |
2865 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2866 | addTypeAttributes(opProto, N__, ResizeBilinearNode::InputIdx, /* isInput */ true); |
2867 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2868 | addTypeAttributes(opProto, N__, ResizeBilinearNode::ResultIdx, /* isInput */ false); |
2869 | addValueAttribute(opProto, "Scale" , N__->getScale()); |
2870 | if (N__->hasPredicate()) { |
2871 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2872 | } |
2873 | break; |
2874 | } |
2875 | |
2876 | case glow::Kinded::Kind::BroadcastNodeKind: { |
2877 | auto *N__ = llvm::cast<BroadcastNode>(node); |
2878 | opProto = graph.add_node(); |
2879 | opProto->set_op_type("Glow_Broadcast" ); |
2880 | opProto->set_name(glow::legalizeName(N__->getName())); |
2881 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2882 | addTypeAttributes(opProto, N__, BroadcastNode::InputIdx, /* isInput */ true); |
2883 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2884 | addTypeAttributes(opProto, N__, BroadcastNode::ResultIdx, /* isInput */ false); |
2885 | addValueAttribute(opProto, "Axis" , N__->getAxis()); |
2886 | addValueAttribute(opProto, "TargetDim" , N__->getTargetDim()); |
2887 | if (N__->hasPredicate()) { |
2888 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2889 | } |
2890 | break; |
2891 | } |
2892 | |
2893 | case glow::Kinded::Kind::SparseLabelSplitNodeKind: { |
2894 | auto *N__ = llvm::cast<SparseLabelSplitNode>(node); |
2895 | opProto = graph.add_node(); |
2896 | opProto->set_op_type("Glow_SparseLabelSplit" ); |
2897 | opProto->set_name(glow::legalizeName(N__->getName())); |
2898 | opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2899 | addTypeAttributes(opProto, N__, SparseLabelSplitNode::LengthsIdx, /* isInput */ true); |
2900 | opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2901 | addTypeAttributes(opProto, N__, SparseLabelSplitNode::IndicesIdx, /* isInput */ true); |
2902 | opProto->add_input(N__->getValues().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2903 | addTypeAttributes(opProto, N__, SparseLabelSplitNode::ValuesIdx, /* isInput */ true); |
2904 | opProto->add_output(N__->getLabelValues().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2905 | addTypeAttributes(opProto, N__, SparseLabelSplitNode::LabelValuesIdx, /* isInput */ false); |
2906 | opProto->add_output(N__->getExampleIds().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2907 | addTypeAttributes(opProto, N__, SparseLabelSplitNode::ExampleIdsIdx, /* isInput */ false); |
2908 | opProto->add_output(N__->getGradientOffsetMap().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2909 | addTypeAttributes(opProto, N__, SparseLabelSplitNode::GradientOffsetMapIdx, /* isInput */ false); |
2910 | addValueAttribute(opProto, "NumLabels" , N__->getNumLabels()); |
2911 | if (N__->hasPredicate()) { |
2912 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2913 | } |
2914 | break; |
2915 | } |
2916 | |
2917 | case glow::Kinded::Kind::FlipNodeKind: { |
2918 | auto *N__ = llvm::cast<FlipNode>(node); |
2919 | opProto = graph.add_node(); |
2920 | opProto->set_op_type("Glow_Flip" ); |
2921 | opProto->set_name(glow::legalizeName(N__->getName())); |
2922 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2923 | addTypeAttributes(opProto, N__, FlipNode::InputIdx, /* isInput */ true); |
2924 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2925 | addTypeAttributes(opProto, N__, FlipNode::ResultIdx, /* isInput */ false); |
2926 | addValueAttribute(opProto, "Axis" , N__->getAxis()); |
2927 | if (N__->hasPredicate()) { |
2928 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2929 | } |
2930 | break; |
2931 | } |
2932 | |
2933 | case glow::Kinded::Kind::SplatNodeKind: { |
2934 | auto *N__ = llvm::cast<SplatNode>(node); |
2935 | opProto = graph.add_node(); |
2936 | opProto->set_op_type("Glow_Splat" ); |
2937 | opProto->set_name(glow::legalizeName(N__->getName())); |
2938 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2939 | addTypeAttributes(opProto, N__, SplatNode::ResultIdx, /* isInput */ false); |
2940 | addValueAttribute(opProto, "Value" , N__->getValue()); |
2941 | if (N__->hasPredicate()) { |
2942 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2943 | } |
2944 | break; |
2945 | } |
2946 | |
2947 | case glow::Kinded::Kind::TouchNodeKind: { |
2948 | auto *N__ = llvm::cast<TouchNode>(node); |
2949 | opProto = graph.add_node(); |
2950 | opProto->set_op_type("Glow_Touch" ); |
2951 | opProto->set_name(glow::legalizeName(N__->getName())); |
2952 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2953 | addTypeAttributes(opProto, N__, TouchNode::ResultIdx, /* isInput */ false); |
2954 | if (N__->hasPredicate()) { |
2955 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2956 | } |
2957 | break; |
2958 | } |
2959 | |
2960 | case glow::Kinded::Kind::SGDNodeKind: { |
2961 | auto *N__ = llvm::cast<SGDNode>(node); |
2962 | opProto = graph.add_node(); |
2963 | opProto->set_op_type("Glow_SGD" ); |
2964 | opProto->set_name(glow::legalizeName(N__->getName())); |
2965 | opProto->add_input(N__->getGradient().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2966 | addTypeAttributes(opProto, N__, SGDNode::GradientIdx, /* isInput */ true); |
2967 | opProto->add_input(N__->getWeight().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2968 | addTypeAttributes(opProto, N__, SGDNode::WeightIdx, /* isInput */ true); |
2969 | opProto->add_output(N__->getUpdatedWeight().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2970 | addTypeAttributes(opProto, N__, SGDNode::UpdatedWeightIdx, /* isInput */ false); |
2971 | addValueAttribute(opProto, "L1Decay" , N__->getL1Decay()); |
2972 | addValueAttribute(opProto, "L2Decay" , N__->getL2Decay()); |
2973 | addValueAttribute(opProto, "LearningRate" , N__->getLearningRate()); |
2974 | addValueAttribute(opProto, "Momentum" , N__->getMomentum()); |
2975 | addValueAttribute(opProto, "BatchSize" , N__->getBatchSize()); |
2976 | if (N__->hasPredicate()) { |
2977 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2978 | } |
2979 | break; |
2980 | } |
2981 | |
2982 | case glow::Kinded::Kind::TraceEventNodeKind: { |
2983 | auto *N__ = llvm::cast<TraceEventNode>(node); |
2984 | opProto = graph.add_node(); |
2985 | opProto->set_op_type("Glow_TraceEvent" ); |
2986 | opProto->set_name(glow::legalizeName(N__->getName())); |
2987 | opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2988 | addTypeAttributes(opProto, N__, TraceEventNode::DataIdx, /* isInput */ true); |
2989 | addValueAttribute(opProto, "EventName" , N__->getEventName()); |
2990 | addValueAttribute(opProto, "EventType" , N__->getEventType()); |
2991 | addValueAttribute(opProto, "Index" , N__->getIndex()); |
2992 | if (N__->hasPredicate()) { |
2993 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
2994 | } |
2995 | break; |
2996 | } |
2997 | |
2998 | case glow::Kinded::Kind::QuantizationProfileNodeKind: { |
2999 | auto *N__ = llvm::cast<QuantizationProfileNode>(node); |
3000 | opProto = graph.add_node(); |
3001 | opProto->set_op_type("Glow_QuantizationProfile" ); |
3002 | opProto->set_name(glow::legalizeName(N__->getName())); |
3003 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3004 | addTypeAttributes(opProto, N__, QuantizationProfileNode::InputIdx, /* isInput */ true); |
3005 | opProto->add_input(N__->getHistogram().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3006 | addTypeAttributes(opProto, N__, QuantizationProfileNode::HistogramIdx, /* isInput */ true); |
3007 | opProto->add_input(N__->getComputationInfo().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3008 | addTypeAttributes(opProto, N__, QuantizationProfileNode::ComputationInfoIdx, /* isInput */ true); |
3009 | addValueAttribute(opProto, "ProfiledNodeName" , N__->getProfiledNodeName()); |
3010 | addValueAttribute(opProto, "ProfiledOutputNumber" , N__->getProfiledOutputNumber()); |
3011 | if (N__->hasPredicate()) { |
3012 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3013 | } |
3014 | break; |
3015 | } |
3016 | |
3017 | case glow::Kinded::Kind::IntLookupTableNodeKind: { |
3018 | auto *N__ = llvm::cast<IntLookupTableNode>(node); |
3019 | opProto = graph.add_node(); |
3020 | opProto->set_op_type("Glow_IntLookupTable" ); |
3021 | opProto->set_name(glow::legalizeName(N__->getName())); |
3022 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3023 | addTypeAttributes(opProto, N__, IntLookupTableNode::InputIdx, /* isInput */ true); |
3024 | opProto->add_input(N__->getMapping().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3025 | addTypeAttributes(opProto, N__, IntLookupTableNode::MappingIdx, /* isInput */ true); |
3026 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3027 | addTypeAttributes(opProto, N__, IntLookupTableNode::ResultIdx, /* isInput */ false); |
3028 | if (N__->hasPredicate()) { |
3029 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3030 | } |
3031 | break; |
3032 | } |
3033 | |
3034 | case glow::Kinded::Kind::QuantizeNodeKind: { |
3035 | auto *N__ = llvm::cast<QuantizeNode>(node); |
3036 | opProto = graph.add_node(); |
3037 | opProto->set_op_type("Glow_Quantize" ); |
3038 | opProto->set_name(glow::legalizeName(N__->getName())); |
3039 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3040 | addTypeAttributes(opProto, N__, QuantizeNode::InputIdx, /* isInput */ true); |
3041 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3042 | addTypeAttributes(opProto, N__, QuantizeNode::ResultIdx, /* isInput */ false); |
3043 | if (N__->hasPredicate()) { |
3044 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3045 | } |
3046 | break; |
3047 | } |
3048 | |
3049 | case glow::Kinded::Kind::DequantizeNodeKind: { |
3050 | auto *N__ = llvm::cast<DequantizeNode>(node); |
3051 | opProto = graph.add_node(); |
3052 | opProto->set_op_type("Glow_Dequantize" ); |
3053 | opProto->set_name(glow::legalizeName(N__->getName())); |
3054 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3055 | addTypeAttributes(opProto, N__, DequantizeNode::InputIdx, /* isInput */ true); |
3056 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3057 | addTypeAttributes(opProto, N__, DequantizeNode::ResultIdx, /* isInput */ false); |
3058 | if (N__->hasPredicate()) { |
3059 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3060 | } |
3061 | break; |
3062 | } |
3063 | |
3064 | case glow::Kinded::Kind::RescaleQuantizedNodeKind: { |
3065 | auto *N__ = llvm::cast<RescaleQuantizedNode>(node); |
3066 | opProto = graph.add_node(); |
3067 | opProto->set_op_type("Glow_RescaleQuantized" ); |
3068 | opProto->set_name(glow::legalizeName(N__->getName())); |
3069 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3070 | addTypeAttributes(opProto, N__, RescaleQuantizedNode::InputIdx, /* isInput */ true); |
3071 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3072 | addTypeAttributes(opProto, N__, RescaleQuantizedNode::ResultIdx, /* isInput */ false); |
3073 | if (N__->hasPredicate()) { |
3074 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3075 | } |
3076 | break; |
3077 | } |
3078 | |
3079 | case glow::Kinded::Kind::TopKNodeKind: { |
3080 | auto *N__ = llvm::cast<TopKNode>(node); |
3081 | opProto = graph.add_node(); |
3082 | opProto->set_op_type("Glow_TopK" ); |
3083 | opProto->set_name(glow::legalizeName(N__->getName())); |
3084 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3085 | addTypeAttributes(opProto, N__, TopKNode::InputIdx, /* isInput */ true); |
3086 | opProto->add_output(N__->getValues().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3087 | addTypeAttributes(opProto, N__, TopKNode::ValuesIdx, /* isInput */ false); |
3088 | opProto->add_output(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3089 | addTypeAttributes(opProto, N__, TopKNode::IndicesIdx, /* isInput */ false); |
3090 | addValueAttribute(opProto, "K" , N__->getK()); |
3091 | if (N__->hasPredicate()) { |
3092 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3093 | } |
3094 | break; |
3095 | } |
3096 | |
3097 | case glow::Kinded::Kind::LSTMUnitNodeKind: { |
3098 | auto *N__ = llvm::cast<LSTMUnitNode>(node); |
3099 | opProto = graph.add_node(); |
3100 | opProto->set_op_type("Glow_LSTMUnit" ); |
3101 | opProto->set_name(glow::legalizeName(N__->getName())); |
3102 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3103 | addTypeAttributes(opProto, N__, LSTMUnitNode::InputIdx, /* isInput */ true); |
3104 | opProto->add_input(N__->getC().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3105 | addTypeAttributes(opProto, N__, LSTMUnitNode::CIdx, /* isInput */ true); |
3106 | opProto->add_output(N__->getnewC().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3107 | addTypeAttributes(opProto, N__, LSTMUnitNode::newCIdx, /* isInput */ false); |
3108 | opProto->add_output(N__->getnewH().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3109 | addTypeAttributes(opProto, N__, LSTMUnitNode::newHIdx, /* isInput */ false); |
3110 | if (N__->hasPredicate()) { |
3111 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3112 | } |
3113 | break; |
3114 | } |
3115 | |
3116 | case glow::Kinded::Kind::ConvertToNodeKind: { |
3117 | auto *N__ = llvm::cast<ConvertToNode>(node); |
3118 | opProto = graph.add_node(); |
3119 | opProto->set_op_type("Glow_ConvertTo" ); |
3120 | opProto->set_name(glow::legalizeName(N__->getName())); |
3121 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3122 | addTypeAttributes(opProto, N__, ConvertToNode::InputIdx, /* isInput */ true); |
3123 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3124 | addTypeAttributes(opProto, N__, ConvertToNode::ResultIdx, /* isInput */ false); |
3125 | if (N__->hasPredicate()) { |
3126 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3127 | } |
3128 | break; |
3129 | } |
3130 | |
3131 | case glow::Kinded::Kind::AudioSpectrogramNodeKind: { |
3132 | auto *N__ = llvm::cast<AudioSpectrogramNode>(node); |
3133 | opProto = graph.add_node(); |
3134 | opProto->set_op_type("Glow_AudioSpectrogram" ); |
3135 | opProto->set_name(glow::legalizeName(N__->getName())); |
3136 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3137 | addTypeAttributes(opProto, N__, AudioSpectrogramNode::InputIdx, /* isInput */ true); |
3138 | opProto->add_input(N__->getWindow().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3139 | addTypeAttributes(opProto, N__, AudioSpectrogramNode::WindowIdx, /* isInput */ true); |
3140 | opProto->add_input(N__->getTwiddleFactors().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3141 | addTypeAttributes(opProto, N__, AudioSpectrogramNode::TwiddleFactorsIdx, /* isInput */ true); |
3142 | opProto->add_input(N__->getBitReverseIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3143 | addTypeAttributes(opProto, N__, AudioSpectrogramNode::BitReverseIndicesIdx, /* isInput */ true); |
3144 | opProto->add_input(N__->getComplexToRealWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3145 | addTypeAttributes(opProto, N__, AudioSpectrogramNode::ComplexToRealWeightsIdx, /* isInput */ true); |
3146 | opProto->add_output(N__->getSpectrogram().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3147 | addTypeAttributes(opProto, N__, AudioSpectrogramNode::SpectrogramIdx, /* isInput */ false); |
3148 | addValueAttribute(opProto, "WindowSize" , N__->getWindowSize()); |
3149 | addValueAttribute(opProto, "WindowStride" , N__->getWindowStride()); |
3150 | addValueAttribute(opProto, "MagnitudeSquared" , N__->getMagnitudeSquared()); |
3151 | if (N__->hasPredicate()) { |
3152 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3153 | } |
3154 | break; |
3155 | } |
3156 | |
3157 | case glow::Kinded::Kind::MFCCNodeKind: { |
3158 | auto *N__ = llvm::cast<MFCCNode>(node); |
3159 | opProto = graph.add_node(); |
3160 | opProto->set_op_type("Glow_MFCC" ); |
3161 | opProto->set_name(glow::legalizeName(N__->getName())); |
3162 | opProto->add_input(N__->getSpectrogram().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3163 | addTypeAttributes(opProto, N__, MFCCNode::SpectrogramIdx, /* isInput */ true); |
3164 | opProto->add_input(N__->getMelWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3165 | addTypeAttributes(opProto, N__, MFCCNode::MelWeightsIdx, /* isInput */ true); |
3166 | opProto->add_input(N__->getMelRanges().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3167 | addTypeAttributes(opProto, N__, MFCCNode::MelRangesIdx, /* isInput */ true); |
3168 | opProto->add_input(N__->getDctMat().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3169 | addTypeAttributes(opProto, N__, MFCCNode::DctMatIdx, /* isInput */ true); |
3170 | opProto->add_output(N__->getCoefficients().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3171 | addTypeAttributes(opProto, N__, MFCCNode::CoefficientsIdx, /* isInput */ false); |
3172 | addValueAttribute(opProto, "SampleRate" , N__->getSampleRate()); |
3173 | addValueAttribute(opProto, "LowerFrequency" , N__->getLowerFrequency()); |
3174 | addValueAttribute(opProto, "UpperFrequency" , N__->getUpperFrequency()); |
3175 | addValueAttribute(opProto, "FilterBankCount" , N__->getFilterBankCount()); |
3176 | addValueAttribute(opProto, "NumCoefficients" , N__->getNumCoefficients()); |
3177 | if (N__->hasPredicate()) { |
3178 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3179 | } |
3180 | break; |
3181 | } |
3182 | |
3183 | case glow::Kinded::Kind::NonMaxSuppressionNodeKind: { |
3184 | auto *N__ = llvm::cast<NonMaxSuppressionNode>(node); |
3185 | opProto = graph.add_node(); |
3186 | opProto->set_op_type("Glow_NonMaxSuppression" ); |
3187 | opProto->set_name(glow::legalizeName(N__->getName())); |
3188 | opProto->add_input(N__->getBoxes().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3189 | addTypeAttributes(opProto, N__, NonMaxSuppressionNode::BoxesIdx, /* isInput */ true); |
3190 | opProto->add_input(N__->getScores().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3191 | addTypeAttributes(opProto, N__, NonMaxSuppressionNode::ScoresIdx, /* isInput */ true); |
3192 | opProto->add_output(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3193 | addTypeAttributes(opProto, N__, NonMaxSuppressionNode::IndicesIdx, /* isInput */ false); |
3194 | opProto->add_output(N__->getNumberOfSelectedIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3195 | addTypeAttributes(opProto, N__, NonMaxSuppressionNode::NumberOfSelectedIndicesIdx, /* isInput */ false); |
3196 | addValueAttribute(opProto, "CenterPointBox" , N__->getCenterPointBox()); |
3197 | addValueAttribute(opProto, "MaxOutputBoxesPerClass" , N__->getMaxOutputBoxesPerClass()); |
3198 | addValueAttribute(opProto, "IouThreshold" , N__->getIouThreshold()); |
3199 | addValueAttribute(opProto, "ScoreThreshold" , N__->getScoreThreshold()); |
3200 | addValueAttribute(opProto, "IsTFVersion4" , N__->getIsTFVersion4()); |
3201 | if (N__->hasPredicate()) { |
3202 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3203 | } |
3204 | break; |
3205 | } |
3206 | |
3207 | case glow::Kinded::Kind::TFLiteDetectionPostProcessNodeKind: { |
3208 | auto *N__ = llvm::cast<TFLiteDetectionPostProcessNode>(node); |
3209 | opProto = graph.add_node(); |
3210 | opProto->set_op_type("Glow_TFLiteDetectionPostProcess" ); |
3211 | opProto->set_name(glow::legalizeName(N__->getName())); |
3212 | opProto->add_input(N__->getBoxes().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3213 | addTypeAttributes(opProto, N__, TFLiteDetectionPostProcessNode::BoxesIdx, /* isInput */ true); |
3214 | opProto->add_input(N__->getScores().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3215 | addTypeAttributes(opProto, N__, TFLiteDetectionPostProcessNode::ScoresIdx, /* isInput */ true); |
3216 | opProto->add_input(N__->getAnchors().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3217 | addTypeAttributes(opProto, N__, TFLiteDetectionPostProcessNode::AnchorsIdx, /* isInput */ true); |
3218 | opProto->add_output(N__->getDetectionBoxes().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3219 | addTypeAttributes(opProto, N__, TFLiteDetectionPostProcessNode::DetectionBoxesIdx, /* isInput */ false); |
3220 | opProto->add_output(N__->getDetectionClasses().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3221 | addTypeAttributes(opProto, N__, TFLiteDetectionPostProcessNode::DetectionClassesIdx, /* isInput */ false); |
3222 | opProto->add_output(N__->getDetectionScores().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3223 | addTypeAttributes(opProto, N__, TFLiteDetectionPostProcessNode::DetectionScoresIdx, /* isInput */ false); |
3224 | opProto->add_output(N__->getNumDetections().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3225 | addTypeAttributes(opProto, N__, TFLiteDetectionPostProcessNode::NumDetectionsIdx, /* isInput */ false); |
3226 | addValueAttribute(opProto, "NumClasses" , N__->getNumClasses()); |
3227 | addValueAttribute(opProto, "MaxDetections" , N__->getMaxDetections()); |
3228 | addValueAttribute(opProto, "MaxClassesPerDetection" , N__->getMaxClassesPerDetection()); |
3229 | addValueAttribute(opProto, "MaxDetectionsPerClass" , N__->getMaxDetectionsPerClass()); |
3230 | addValueAttribute(opProto, "IouThreshold" , N__->getIouThreshold()); |
3231 | addValueAttribute(opProto, "ScoreThreshold" , N__->getScoreThreshold()); |
3232 | addValueAttribute(opProto, "XScale" , N__->getXScale()); |
3233 | addValueAttribute(opProto, "YScale" , N__->getYScale()); |
3234 | addValueAttribute(opProto, "HScale" , N__->getHScale()); |
3235 | addValueAttribute(opProto, "WScale" , N__->getWScale()); |
3236 | addValueAttribute(opProto, "RegularNMS" , N__->getRegularNMS()); |
3237 | if (N__->hasPredicate()) { |
3238 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3239 | } |
3240 | break; |
3241 | } |
3242 | |
3243 | case glow::Kinded::Kind::ROIAlignNodeKind: { |
3244 | auto *N__ = llvm::cast<ROIAlignNode>(node); |
3245 | opProto = graph.add_node(); |
3246 | opProto->set_op_type("Glow_ROIAlign" ); |
3247 | opProto->set_name(glow::legalizeName(N__->getName())); |
3248 | opProto->add_input(N__->getFeatureMap().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3249 | addTypeAttributes(opProto, N__, ROIAlignNode::FeatureMapIdx, /* isInput */ true); |
3250 | opProto->add_input(N__->getBoxes().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3251 | addTypeAttributes(opProto, N__, ROIAlignNode::BoxesIdx, /* isInput */ true); |
3252 | opProto->add_input(N__->getBatchIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3253 | addTypeAttributes(opProto, N__, ROIAlignNode::BatchIndicesIdx, /* isInput */ true); |
3254 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3255 | addTypeAttributes(opProto, N__, ROIAlignNode::ResultIdx, /* isInput */ false); |
3256 | addValueAttribute(opProto, "Mode" , N__->getMode()); |
3257 | addValueAttribute(opProto, "OutputHeight" , N__->getOutputHeight()); |
3258 | addValueAttribute(opProto, "OutputWidth" , N__->getOutputWidth()); |
3259 | addValueAttribute(opProto, "SamplingRatio" , N__->getSamplingRatio()); |
3260 | addValueAttribute(opProto, "SpatialScale" , N__->getSpatialScale()); |
3261 | addValueAttribute(opProto, "Aligned" , N__->getAligned()); |
3262 | addValueAttribute(opProto, "Rotated" , N__->getRotated()); |
3263 | if (N__->hasPredicate()) { |
3264 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3265 | } |
3266 | break; |
3267 | } |
3268 | |
3269 | case glow::Kinded::Kind::BBoxTransformNodeKind: { |
3270 | auto *N__ = llvm::cast<BBoxTransformNode>(node); |
3271 | opProto = graph.add_node(); |
3272 | opProto->set_op_type("Glow_BBoxTransform" ); |
3273 | opProto->set_name(glow::legalizeName(N__->getName())); |
3274 | opProto->add_input(N__->getRois().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3275 | addTypeAttributes(opProto, N__, BBoxTransformNode::RoisIdx, /* isInput */ true); |
3276 | opProto->add_input(N__->getDeltas().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3277 | addTypeAttributes(opProto, N__, BBoxTransformNode::DeltasIdx, /* isInput */ true); |
3278 | opProto->add_input(N__->getImInfo().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3279 | addTypeAttributes(opProto, N__, BBoxTransformNode::ImInfoIdx, /* isInput */ true); |
3280 | opProto->add_output(N__->getBoxOut().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3281 | addTypeAttributes(opProto, N__, BBoxTransformNode::BoxOutIdx, /* isInput */ false); |
3282 | opProto->add_output(N__->getRoiBatchSplits().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3283 | addTypeAttributes(opProto, N__, BBoxTransformNode::RoiBatchSplitsIdx, /* isInput */ false); |
3284 | addValueAttribute(opProto, "Weights" , N__->getWeights()); |
3285 | addValueAttribute(opProto, "ApplyScale" , N__->getApplyScale()); |
3286 | addValueAttribute(opProto, "Rotated" , N__->getRotated()); |
3287 | addValueAttribute(opProto, "AngleBoundOn" , N__->getAngleBoundOn()); |
3288 | addValueAttribute(opProto, "AngleBoundLo" , N__->getAngleBoundLo()); |
3289 | addValueAttribute(opProto, "AngleBoundHi" , N__->getAngleBoundHi()); |
3290 | addValueAttribute(opProto, "ClipAngleThresh" , N__->getClipAngleThresh()); |
3291 | addValueAttribute(opProto, "LegacyPlusOne" , N__->getLegacyPlusOne()); |
3292 | if (N__->hasPredicate()) { |
3293 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3294 | } |
3295 | break; |
3296 | } |
3297 | |
3298 | case glow::Kinded::Kind::CollectRpnProposalsNodeKind: { |
3299 | auto *N__ = llvm::cast<CollectRpnProposalsNode>(node); |
3300 | opProto = graph.add_node(); |
3301 | opProto->set_op_type("Glow_CollectRpnProposals" ); |
3302 | opProto->set_name(glow::legalizeName(N__->getName())); |
3303 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3304 | addTypeAttributes(opProto, N__, CollectRpnProposalsNode::ResultIdx, /* isInput */ false); |
3305 | addValueAttribute(opProto, "RoisIn" , N__->getRoisIn()); |
3306 | for (unsigned i = 0, e = N__->getRoisIn().size(); i < e; i++) { |
3307 | addTypeAttributes(opProto, N__->getRoisIn()[i], i, /* isInput */ true, "RoisIn_" ); |
3308 | } |
3309 | addValueAttribute(opProto, "RoisProbsIn" , N__->getRoisProbsIn()); |
3310 | for (unsigned i = 0, e = N__->getRoisProbsIn().size(); i < e; i++) { |
3311 | addTypeAttributes(opProto, N__->getRoisProbsIn()[i], i, /* isInput */ true, "RoisProbsIn_" ); |
3312 | } |
3313 | addValueAttribute(opProto, "RpnMaxLevel" , N__->getRpnMaxLevel()); |
3314 | addValueAttribute(opProto, "RpnMinLevel" , N__->getRpnMinLevel()); |
3315 | addValueAttribute(opProto, "RpnPostNmsTopN" , N__->getRpnPostNmsTopN()); |
3316 | if (N__->hasPredicate()) { |
3317 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3318 | } |
3319 | break; |
3320 | } |
3321 | |
3322 | case glow::Kinded::Kind::LookupTableNodeKind: { |
3323 | auto *N__ = llvm::cast<LookupTableNode>(node); |
3324 | opProto = graph.add_node(); |
3325 | opProto->set_op_type("Glow_LookupTable" ); |
3326 | opProto->set_name(glow::legalizeName(N__->getName())); |
3327 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3328 | addTypeAttributes(opProto, N__, LookupTableNode::InputIdx, /* isInput */ true); |
3329 | opProto->add_input(N__->getTable().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3330 | addTypeAttributes(opProto, N__, LookupTableNode::TableIdx, /* isInput */ true); |
3331 | opProto->add_input(N__->getTableIdx().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3332 | addTypeAttributes(opProto, N__, LookupTableNode::TableIdxIdx, /* isInput */ true); |
3333 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3334 | addTypeAttributes(opProto, N__, LookupTableNode::ResultIdx, /* isInput */ false); |
3335 | addValueAttribute(opProto, "Operator" , N__->getOperator()); |
3336 | addValueAttribute(opProto, "OperatorArgs" , N__->getOperatorArgs()); |
3337 | if (N__->hasPredicate()) { |
3338 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3339 | } |
3340 | break; |
3341 | } |
3342 | |
3343 | case glow::Kinded::Kind::CPUMaxSplatNodeKind: { |
3344 | auto *N__ = llvm::cast<CPUMaxSplatNode>(node); |
3345 | opProto = graph.add_node(); |
3346 | opProto->set_op_type("Glow_CPUMaxSplat" ); |
3347 | opProto->set_name(glow::legalizeName(N__->getName())); |
3348 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3349 | addTypeAttributes(opProto, N__, CPUMaxSplatNode::InputIdx, /* isInput */ true); |
3350 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3351 | addTypeAttributes(opProto, N__, CPUMaxSplatNode::ResultIdx, /* isInput */ false); |
3352 | addValueAttribute(opProto, "SplatValue" , N__->getSplatValue()); |
3353 | if (N__->hasPredicate()) { |
3354 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3355 | } |
3356 | break; |
3357 | } |
3358 | |
3359 | case glow::Kinded::Kind::CPUConvDKKC8NodeKind: { |
3360 | auto *N__ = llvm::cast<CPUConvDKKC8Node>(node); |
3361 | opProto = graph.add_node(); |
3362 | opProto->set_op_type("Glow_CPUConvDKKC8" ); |
3363 | opProto->set_name(glow::legalizeName(N__->getName())); |
3364 | opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3365 | addTypeAttributes(opProto, N__, CPUConvDKKC8Node::InputIdx, /* isInput */ true); |
3366 | opProto->add_input(N__->getFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3367 | addTypeAttributes(opProto, N__, CPUConvDKKC8Node::FilterIdx, /* isInput */ true); |
3368 | opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3369 | addTypeAttributes(opProto, N__, CPUConvDKKC8Node::BiasIdx, /* isInput */ true); |
3370 | opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3371 | addTypeAttributes(opProto, N__, CPUConvDKKC8Node::ResultIdx, /* isInput */ false); |
3372 | addValueAttribute(opProto, "Kernels" , N__->getKernels()); |
3373 | addValueAttribute(opProto, "Strides" , N__->getStrides()); |
3374 | addValueAttribute(opProto, "Pads" , N__->getPads()); |
3375 | addValueAttribute(opProto, "Group" , N__->getGroup()); |
3376 | if (N__->hasPredicate()) { |
3377 | addValueAttribute(opProto, "Predicate" , N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true)); |
3378 | } |
3379 | break; |
3380 | } |
3381 | |
3382 | |