1 | // This file is MACHINE GENERATED! Do not edit. |
2 | |
3 | |
4 | #include "tensorflow/cc/ops/const_op.h" |
5 | #include "tensorflow/cc/ops/math_ops.h" |
6 | |
7 | namespace tensorflow { |
8 | namespace ops { |
9 | |
10 | Abs::Abs(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
11 | if (!scope.ok()) return; |
12 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
13 | if (!scope.ok()) return; |
14 | ::tensorflow::Node* ret; |
15 | const auto unique_name = scope.GetUniqueNameForOp("Abs" ); |
16 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Abs" ) |
17 | .Input(_x) |
18 | ; |
19 | scope.UpdateBuilder(&builder); |
20 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
21 | if (!scope.ok()) return; |
22 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
23 | this->operation = Operation(ret); |
24 | this->y = Output(ret, 0); |
25 | } |
26 | |
27 | AccumulateNV2::AccumulateNV2(const ::tensorflow::Scope& scope, |
28 | ::tensorflow::InputList inputs, PartialTensorShape |
29 | shape) { |
30 | if (!scope.ok()) return; |
31 | auto _inputs = ::tensorflow::ops::AsNodeOutList(scope, inputs); |
32 | if (!scope.ok()) return; |
33 | ::tensorflow::Node* ret; |
34 | const auto unique_name = scope.GetUniqueNameForOp("AccumulateNV2" ); |
35 | auto builder = ::tensorflow::NodeBuilder(unique_name, "AccumulateNV2" ) |
36 | .Input(_inputs) |
37 | .Attr("shape" , shape) |
38 | ; |
39 | scope.UpdateBuilder(&builder); |
40 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
41 | if (!scope.ok()) return; |
42 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
43 | this->operation = Operation(ret); |
44 | this->sum = Output(ret, 0); |
45 | } |
46 | |
47 | Acos::Acos(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
48 | if (!scope.ok()) return; |
49 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
50 | if (!scope.ok()) return; |
51 | ::tensorflow::Node* ret; |
52 | const auto unique_name = scope.GetUniqueNameForOp("Acos" ); |
53 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Acos" ) |
54 | .Input(_x) |
55 | ; |
56 | scope.UpdateBuilder(&builder); |
57 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
58 | if (!scope.ok()) return; |
59 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
60 | this->operation = Operation(ret); |
61 | this->y = Output(ret, 0); |
62 | } |
63 | |
64 | Acosh::Acosh(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
65 | if (!scope.ok()) return; |
66 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
67 | if (!scope.ok()) return; |
68 | ::tensorflow::Node* ret; |
69 | const auto unique_name = scope.GetUniqueNameForOp("Acosh" ); |
70 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Acosh" ) |
71 | .Input(_x) |
72 | ; |
73 | scope.UpdateBuilder(&builder); |
74 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
75 | if (!scope.ok()) return; |
76 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
77 | this->operation = Operation(ret); |
78 | this->y = Output(ret, 0); |
79 | } |
80 | |
81 | Add::Add(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
82 | ::tensorflow::Input y) { |
83 | if (!scope.ok()) return; |
84 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
85 | if (!scope.ok()) return; |
86 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
87 | if (!scope.ok()) return; |
88 | ::tensorflow::Node* ret; |
89 | const auto unique_name = scope.GetUniqueNameForOp("Add" ); |
90 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Add" ) |
91 | .Input(_x) |
92 | .Input(_y) |
93 | ; |
94 | scope.UpdateBuilder(&builder); |
95 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
96 | if (!scope.ok()) return; |
97 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
98 | this->operation = Operation(ret); |
99 | this->z = Output(ret, 0); |
100 | } |
101 | |
102 | AddN::AddN(const ::tensorflow::Scope& scope, ::tensorflow::InputList inputs) { |
103 | if (!scope.ok()) return; |
104 | auto _inputs = ::tensorflow::ops::AsNodeOutList(scope, inputs); |
105 | if (!scope.ok()) return; |
106 | ::tensorflow::Node* ret; |
107 | const auto unique_name = scope.GetUniqueNameForOp("AddN" ); |
108 | auto builder = ::tensorflow::NodeBuilder(unique_name, "AddN" ) |
109 | .Input(_inputs) |
110 | ; |
111 | scope.UpdateBuilder(&builder); |
112 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
113 | if (!scope.ok()) return; |
114 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
115 | this->operation = Operation(ret); |
116 | this->sum = Output(ret, 0); |
117 | } |
118 | |
119 | AddV2::AddV2(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
120 | ::tensorflow::Input y) { |
121 | if (!scope.ok()) return; |
122 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
123 | if (!scope.ok()) return; |
124 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
125 | if (!scope.ok()) return; |
126 | ::tensorflow::Node* ret; |
127 | const auto unique_name = scope.GetUniqueNameForOp("AddV2" ); |
128 | auto builder = ::tensorflow::NodeBuilder(unique_name, "AddV2" ) |
129 | .Input(_x) |
130 | .Input(_y) |
131 | ; |
132 | scope.UpdateBuilder(&builder); |
133 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
134 | if (!scope.ok()) return; |
135 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
136 | this->operation = Operation(ret); |
137 | this->z = Output(ret, 0); |
138 | } |
139 | |
140 | All::All(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
141 | ::tensorflow::Input axis, const All::Attrs& attrs) { |
142 | if (!scope.ok()) return; |
143 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
144 | if (!scope.ok()) return; |
145 | auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis); |
146 | if (!scope.ok()) return; |
147 | ::tensorflow::Node* ret; |
148 | const auto unique_name = scope.GetUniqueNameForOp("All" ); |
149 | auto builder = ::tensorflow::NodeBuilder(unique_name, "All" ) |
150 | .Input(_input) |
151 | .Input(_axis) |
152 | .Attr("keep_dims" , attrs.keep_dims_) |
153 | ; |
154 | scope.UpdateBuilder(&builder); |
155 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
156 | if (!scope.ok()) return; |
157 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
158 | this->operation = Operation(ret); |
159 | this->output = Output(ret, 0); |
160 | } |
161 | |
162 | All::All(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
163 | ::tensorflow::Input axis) |
164 | : All(scope, input, axis, All::Attrs()) {} |
165 | |
166 | Angle::Angle(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const |
167 | Angle::Attrs& attrs) { |
168 | if (!scope.ok()) return; |
169 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
170 | if (!scope.ok()) return; |
171 | ::tensorflow::Node* ret; |
172 | const auto unique_name = scope.GetUniqueNameForOp("Angle" ); |
173 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Angle" ) |
174 | .Input(_input) |
175 | .Attr("Tout" , attrs.Tout_) |
176 | ; |
177 | scope.UpdateBuilder(&builder); |
178 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
179 | if (!scope.ok()) return; |
180 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
181 | this->operation = Operation(ret); |
182 | this->output = Output(ret, 0); |
183 | } |
184 | |
185 | Angle::Angle(const ::tensorflow::Scope& scope, ::tensorflow::Input input) |
186 | : Angle(scope, input, Angle::Attrs()) {} |
187 | |
188 | Any::Any(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
189 | ::tensorflow::Input axis, const Any::Attrs& attrs) { |
190 | if (!scope.ok()) return; |
191 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
192 | if (!scope.ok()) return; |
193 | auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis); |
194 | if (!scope.ok()) return; |
195 | ::tensorflow::Node* ret; |
196 | const auto unique_name = scope.GetUniqueNameForOp("Any" ); |
197 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Any" ) |
198 | .Input(_input) |
199 | .Input(_axis) |
200 | .Attr("keep_dims" , attrs.keep_dims_) |
201 | ; |
202 | scope.UpdateBuilder(&builder); |
203 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
204 | if (!scope.ok()) return; |
205 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
206 | this->operation = Operation(ret); |
207 | this->output = Output(ret, 0); |
208 | } |
209 | |
210 | Any::Any(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
211 | ::tensorflow::Input axis) |
212 | : Any(scope, input, axis, Any::Attrs()) {} |
213 | |
214 | ApproximateEqual::ApproximateEqual(const ::tensorflow::Scope& scope, |
215 | ::tensorflow::Input x, ::tensorflow::Input |
216 | y, const ApproximateEqual::Attrs& attrs) { |
217 | if (!scope.ok()) return; |
218 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
219 | if (!scope.ok()) return; |
220 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
221 | if (!scope.ok()) return; |
222 | ::tensorflow::Node* ret; |
223 | const auto unique_name = scope.GetUniqueNameForOp("ApproximateEqual" ); |
224 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ApproximateEqual" ) |
225 | .Input(_x) |
226 | .Input(_y) |
227 | .Attr("tolerance" , attrs.tolerance_) |
228 | ; |
229 | scope.UpdateBuilder(&builder); |
230 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
231 | if (!scope.ok()) return; |
232 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
233 | this->operation = Operation(ret); |
234 | this->z = Output(ret, 0); |
235 | } |
236 | |
237 | ApproximateEqual::ApproximateEqual(const ::tensorflow::Scope& scope, |
238 | ::tensorflow::Input x, ::tensorflow::Input |
239 | y) |
240 | : ApproximateEqual(scope, x, y, ApproximateEqual::Attrs()) {} |
241 | |
242 | ArgMax::ArgMax(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
243 | ::tensorflow::Input dimension, const ArgMax::Attrs& attrs) { |
244 | if (!scope.ok()) return; |
245 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
246 | if (!scope.ok()) return; |
247 | auto _dimension = ::tensorflow::ops::AsNodeOut(scope, dimension); |
248 | if (!scope.ok()) return; |
249 | ::tensorflow::Node* ret; |
250 | const auto unique_name = scope.GetUniqueNameForOp("ArgMax" ); |
251 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ArgMax" ) |
252 | .Input(_input) |
253 | .Input(_dimension) |
254 | .Attr("output_type" , attrs.output_type_) |
255 | ; |
256 | scope.UpdateBuilder(&builder); |
257 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
258 | if (!scope.ok()) return; |
259 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
260 | this->operation = Operation(ret); |
261 | this->output = Output(ret, 0); |
262 | } |
263 | |
264 | ArgMax::ArgMax(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
265 | ::tensorflow::Input dimension) |
266 | : ArgMax(scope, input, dimension, ArgMax::Attrs()) {} |
267 | |
268 | ArgMin::ArgMin(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
269 | ::tensorflow::Input dimension, const ArgMin::Attrs& attrs) { |
270 | if (!scope.ok()) return; |
271 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
272 | if (!scope.ok()) return; |
273 | auto _dimension = ::tensorflow::ops::AsNodeOut(scope, dimension); |
274 | if (!scope.ok()) return; |
275 | ::tensorflow::Node* ret; |
276 | const auto unique_name = scope.GetUniqueNameForOp("ArgMin" ); |
277 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ArgMin" ) |
278 | .Input(_input) |
279 | .Input(_dimension) |
280 | .Attr("output_type" , attrs.output_type_) |
281 | ; |
282 | scope.UpdateBuilder(&builder); |
283 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
284 | if (!scope.ok()) return; |
285 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
286 | this->operation = Operation(ret); |
287 | this->output = Output(ret, 0); |
288 | } |
289 | |
290 | ArgMin::ArgMin(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
291 | ::tensorflow::Input dimension) |
292 | : ArgMin(scope, input, dimension, ArgMin::Attrs()) {} |
293 | |
294 | Asin::Asin(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
295 | if (!scope.ok()) return; |
296 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
297 | if (!scope.ok()) return; |
298 | ::tensorflow::Node* ret; |
299 | const auto unique_name = scope.GetUniqueNameForOp("Asin" ); |
300 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Asin" ) |
301 | .Input(_x) |
302 | ; |
303 | scope.UpdateBuilder(&builder); |
304 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
305 | if (!scope.ok()) return; |
306 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
307 | this->operation = Operation(ret); |
308 | this->y = Output(ret, 0); |
309 | } |
310 | |
311 | Asinh::Asinh(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
312 | if (!scope.ok()) return; |
313 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
314 | if (!scope.ok()) return; |
315 | ::tensorflow::Node* ret; |
316 | const auto unique_name = scope.GetUniqueNameForOp("Asinh" ); |
317 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Asinh" ) |
318 | .Input(_x) |
319 | ; |
320 | scope.UpdateBuilder(&builder); |
321 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
322 | if (!scope.ok()) return; |
323 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
324 | this->operation = Operation(ret); |
325 | this->y = Output(ret, 0); |
326 | } |
327 | |
328 | Atan::Atan(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
329 | if (!scope.ok()) return; |
330 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
331 | if (!scope.ok()) return; |
332 | ::tensorflow::Node* ret; |
333 | const auto unique_name = scope.GetUniqueNameForOp("Atan" ); |
334 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Atan" ) |
335 | .Input(_x) |
336 | ; |
337 | scope.UpdateBuilder(&builder); |
338 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
339 | if (!scope.ok()) return; |
340 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
341 | this->operation = Operation(ret); |
342 | this->y = Output(ret, 0); |
343 | } |
344 | |
345 | Atan2::Atan2(const ::tensorflow::Scope& scope, ::tensorflow::Input y, |
346 | ::tensorflow::Input x) { |
347 | if (!scope.ok()) return; |
348 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
349 | if (!scope.ok()) return; |
350 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
351 | if (!scope.ok()) return; |
352 | ::tensorflow::Node* ret; |
353 | const auto unique_name = scope.GetUniqueNameForOp("Atan2" ); |
354 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Atan2" ) |
355 | .Input(_y) |
356 | .Input(_x) |
357 | ; |
358 | scope.UpdateBuilder(&builder); |
359 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
360 | if (!scope.ok()) return; |
361 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
362 | this->operation = Operation(ret); |
363 | this->z = Output(ret, 0); |
364 | } |
365 | |
366 | Atanh::Atanh(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
367 | if (!scope.ok()) return; |
368 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
369 | if (!scope.ok()) return; |
370 | ::tensorflow::Node* ret; |
371 | const auto unique_name = scope.GetUniqueNameForOp("Atanh" ); |
372 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Atanh" ) |
373 | .Input(_x) |
374 | ; |
375 | scope.UpdateBuilder(&builder); |
376 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
377 | if (!scope.ok()) return; |
378 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
379 | this->operation = Operation(ret); |
380 | this->y = Output(ret, 0); |
381 | } |
382 | |
383 | BatchMatMul::BatchMatMul(const ::tensorflow::Scope& scope, ::tensorflow::Input |
384 | x, ::tensorflow::Input y, const BatchMatMul::Attrs& |
385 | attrs) { |
386 | if (!scope.ok()) return; |
387 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
388 | if (!scope.ok()) return; |
389 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
390 | if (!scope.ok()) return; |
391 | ::tensorflow::Node* ret; |
392 | const auto unique_name = scope.GetUniqueNameForOp("BatchMatMul" ); |
393 | auto builder = ::tensorflow::NodeBuilder(unique_name, "BatchMatMul" ) |
394 | .Input(_x) |
395 | .Input(_y) |
396 | .Attr("adj_x" , attrs.adj_x_) |
397 | .Attr("adj_y" , attrs.adj_y_) |
398 | ; |
399 | scope.UpdateBuilder(&builder); |
400 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
401 | if (!scope.ok()) return; |
402 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
403 | this->operation = Operation(ret); |
404 | this->output = Output(ret, 0); |
405 | } |
406 | |
407 | BatchMatMul::BatchMatMul(const ::tensorflow::Scope& scope, ::tensorflow::Input |
408 | x, ::tensorflow::Input y) |
409 | : BatchMatMul(scope, x, y, BatchMatMul::Attrs()) {} |
410 | |
411 | BatchMatMulV2::BatchMatMulV2(const ::tensorflow::Scope& scope, |
412 | ::tensorflow::Input x, ::tensorflow::Input y, |
413 | const BatchMatMulV2::Attrs& attrs) { |
414 | if (!scope.ok()) return; |
415 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
416 | if (!scope.ok()) return; |
417 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
418 | if (!scope.ok()) return; |
419 | ::tensorflow::Node* ret; |
420 | const auto unique_name = scope.GetUniqueNameForOp("BatchMatMulV2" ); |
421 | auto builder = ::tensorflow::NodeBuilder(unique_name, "BatchMatMulV2" ) |
422 | .Input(_x) |
423 | .Input(_y) |
424 | .Attr("adj_x" , attrs.adj_x_) |
425 | .Attr("adj_y" , attrs.adj_y_) |
426 | ; |
427 | scope.UpdateBuilder(&builder); |
428 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
429 | if (!scope.ok()) return; |
430 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
431 | this->operation = Operation(ret); |
432 | this->output = Output(ret, 0); |
433 | } |
434 | |
435 | BatchMatMulV2::BatchMatMulV2(const ::tensorflow::Scope& scope, |
436 | ::tensorflow::Input x, ::tensorflow::Input y) |
437 | : BatchMatMulV2(scope, x, y, BatchMatMulV2::Attrs()) {} |
438 | |
439 | BatchMatMulV3::BatchMatMulV3(const ::tensorflow::Scope& scope, |
440 | ::tensorflow::Input x, ::tensorflow::Input y, |
441 | DataType Tout, const BatchMatMulV3::Attrs& attrs) { |
442 | if (!scope.ok()) return; |
443 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
444 | if (!scope.ok()) return; |
445 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
446 | if (!scope.ok()) return; |
447 | ::tensorflow::Node* ret; |
448 | const auto unique_name = scope.GetUniqueNameForOp("BatchMatMulV3" ); |
449 | auto builder = ::tensorflow::NodeBuilder(unique_name, "BatchMatMulV3" ) |
450 | .Input(_x) |
451 | .Input(_y) |
452 | .Attr("Tout" , Tout) |
453 | .Attr("adj_x" , attrs.adj_x_) |
454 | .Attr("adj_y" , attrs.adj_y_) |
455 | ; |
456 | scope.UpdateBuilder(&builder); |
457 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
458 | if (!scope.ok()) return; |
459 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
460 | this->operation = Operation(ret); |
461 | this->output = Output(ret, 0); |
462 | } |
463 | |
464 | BatchMatMulV3::BatchMatMulV3(const ::tensorflow::Scope& scope, |
465 | ::tensorflow::Input x, ::tensorflow::Input y, |
466 | DataType Tout) |
467 | : BatchMatMulV3(scope, x, y, Tout, BatchMatMulV3::Attrs()) {} |
468 | |
469 | Betainc::Betainc(const ::tensorflow::Scope& scope, ::tensorflow::Input a, |
470 | ::tensorflow::Input b, ::tensorflow::Input x) { |
471 | if (!scope.ok()) return; |
472 | auto _a = ::tensorflow::ops::AsNodeOut(scope, a); |
473 | if (!scope.ok()) return; |
474 | auto _b = ::tensorflow::ops::AsNodeOut(scope, b); |
475 | if (!scope.ok()) return; |
476 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
477 | if (!scope.ok()) return; |
478 | ::tensorflow::Node* ret; |
479 | const auto unique_name = scope.GetUniqueNameForOp("Betainc" ); |
480 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Betainc" ) |
481 | .Input(_a) |
482 | .Input(_b) |
483 | .Input(_x) |
484 | ; |
485 | scope.UpdateBuilder(&builder); |
486 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
487 | if (!scope.ok()) return; |
488 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
489 | this->operation = Operation(ret); |
490 | this->z = Output(ret, 0); |
491 | } |
492 | |
493 | Bincount::Bincount(const ::tensorflow::Scope& scope, ::tensorflow::Input arr, |
494 | ::tensorflow::Input size, ::tensorflow::Input weights) { |
495 | if (!scope.ok()) return; |
496 | auto _arr = ::tensorflow::ops::AsNodeOut(scope, arr); |
497 | if (!scope.ok()) return; |
498 | auto _size = ::tensorflow::ops::AsNodeOut(scope, size); |
499 | if (!scope.ok()) return; |
500 | auto _weights = ::tensorflow::ops::AsNodeOut(scope, weights); |
501 | if (!scope.ok()) return; |
502 | ::tensorflow::Node* ret; |
503 | const auto unique_name = scope.GetUniqueNameForOp("Bincount" ); |
504 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Bincount" ) |
505 | .Input(_arr) |
506 | .Input(_size) |
507 | .Input(_weights) |
508 | ; |
509 | scope.UpdateBuilder(&builder); |
510 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
511 | if (!scope.ok()) return; |
512 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
513 | this->operation = Operation(ret); |
514 | this->bins = Output(ret, 0); |
515 | } |
516 | |
517 | Bucketize::Bucketize(const ::tensorflow::Scope& scope, ::tensorflow::Input |
518 | input, const gtl::ArraySlice<float>& boundaries) { |
519 | if (!scope.ok()) return; |
520 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
521 | if (!scope.ok()) return; |
522 | ::tensorflow::Node* ret; |
523 | const auto unique_name = scope.GetUniqueNameForOp("Bucketize" ); |
524 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Bucketize" ) |
525 | .Input(_input) |
526 | .Attr("boundaries" , boundaries) |
527 | ; |
528 | scope.UpdateBuilder(&builder); |
529 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
530 | if (!scope.ok()) return; |
531 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
532 | this->operation = Operation(ret); |
533 | this->output = Output(ret, 0); |
534 | } |
535 | |
536 | Cast::Cast(const ::tensorflow::Scope& scope, ::tensorflow::Input x, DataType |
537 | DstT, const Cast::Attrs& attrs) { |
538 | if (!scope.ok()) return; |
539 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
540 | if (!scope.ok()) return; |
541 | ::tensorflow::Node* ret; |
542 | const auto unique_name = scope.GetUniqueNameForOp("Cast" ); |
543 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Cast" ) |
544 | .Input(_x) |
545 | .Attr("DstT" , DstT) |
546 | .Attr("Truncate" , attrs.Truncate_) |
547 | ; |
548 | scope.UpdateBuilder(&builder); |
549 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
550 | if (!scope.ok()) return; |
551 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
552 | this->operation = Operation(ret); |
553 | this->y = Output(ret, 0); |
554 | } |
555 | |
556 | Cast::Cast(const ::tensorflow::Scope& scope, ::tensorflow::Input x, DataType |
557 | DstT) |
558 | : Cast(scope, x, DstT, Cast::Attrs()) {} |
559 | |
560 | Ceil::Ceil(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
561 | if (!scope.ok()) return; |
562 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
563 | if (!scope.ok()) return; |
564 | ::tensorflow::Node* ret; |
565 | const auto unique_name = scope.GetUniqueNameForOp("Ceil" ); |
566 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Ceil" ) |
567 | .Input(_x) |
568 | ; |
569 | scope.UpdateBuilder(&builder); |
570 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
571 | if (!scope.ok()) return; |
572 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
573 | this->operation = Operation(ret); |
574 | this->y = Output(ret, 0); |
575 | } |
576 | |
577 | ClipByValue::ClipByValue(const ::tensorflow::Scope& scope, ::tensorflow::Input |
578 | t, ::tensorflow::Input clip_value_min, |
579 | ::tensorflow::Input clip_value_max) { |
580 | if (!scope.ok()) return; |
581 | auto _t = ::tensorflow::ops::AsNodeOut(scope, t); |
582 | if (!scope.ok()) return; |
583 | auto _clip_value_min = ::tensorflow::ops::AsNodeOut(scope, clip_value_min); |
584 | if (!scope.ok()) return; |
585 | auto _clip_value_max = ::tensorflow::ops::AsNodeOut(scope, clip_value_max); |
586 | if (!scope.ok()) return; |
587 | ::tensorflow::Node* ret; |
588 | const auto unique_name = scope.GetUniqueNameForOp("ClipByValue" ); |
589 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ClipByValue" ) |
590 | .Input(_t) |
591 | .Input(_clip_value_min) |
592 | .Input(_clip_value_max) |
593 | ; |
594 | scope.UpdateBuilder(&builder); |
595 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
596 | if (!scope.ok()) return; |
597 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
598 | this->operation = Operation(ret); |
599 | this->output = Output(ret, 0); |
600 | } |
601 | |
602 | Complex::Complex(const ::tensorflow::Scope& scope, ::tensorflow::Input real, |
603 | ::tensorflow::Input imag, const Complex::Attrs& attrs) { |
604 | if (!scope.ok()) return; |
605 | auto _real = ::tensorflow::ops::AsNodeOut(scope, real); |
606 | if (!scope.ok()) return; |
607 | auto _imag = ::tensorflow::ops::AsNodeOut(scope, imag); |
608 | if (!scope.ok()) return; |
609 | ::tensorflow::Node* ret; |
610 | const auto unique_name = scope.GetUniqueNameForOp("Complex" ); |
611 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Complex" ) |
612 | .Input(_real) |
613 | .Input(_imag) |
614 | .Attr("Tout" , attrs.Tout_) |
615 | ; |
616 | scope.UpdateBuilder(&builder); |
617 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
618 | if (!scope.ok()) return; |
619 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
620 | this->operation = Operation(ret); |
621 | this->out = Output(ret, 0); |
622 | } |
623 | |
624 | Complex::Complex(const ::tensorflow::Scope& scope, ::tensorflow::Input real, |
625 | ::tensorflow::Input imag) |
626 | : Complex(scope, real, imag, Complex::Attrs()) {} |
627 | |
628 | ComplexAbs::ComplexAbs(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
629 | const ComplexAbs::Attrs& attrs) { |
630 | if (!scope.ok()) return; |
631 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
632 | if (!scope.ok()) return; |
633 | ::tensorflow::Node* ret; |
634 | const auto unique_name = scope.GetUniqueNameForOp("ComplexAbs" ); |
635 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ComplexAbs" ) |
636 | .Input(_x) |
637 | .Attr("Tout" , attrs.Tout_) |
638 | ; |
639 | scope.UpdateBuilder(&builder); |
640 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
641 | if (!scope.ok()) return; |
642 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
643 | this->operation = Operation(ret); |
644 | this->y = Output(ret, 0); |
645 | } |
646 | |
647 | ComplexAbs::ComplexAbs(const ::tensorflow::Scope& scope, ::tensorflow::Input x) |
648 | : ComplexAbs(scope, x, ComplexAbs::Attrs()) {} |
649 | |
650 | Conj::Conj(const ::tensorflow::Scope& scope, ::tensorflow::Input input) { |
651 | if (!scope.ok()) return; |
652 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
653 | if (!scope.ok()) return; |
654 | ::tensorflow::Node* ret; |
655 | const auto unique_name = scope.GetUniqueNameForOp("Conj" ); |
656 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Conj" ) |
657 | .Input(_input) |
658 | ; |
659 | scope.UpdateBuilder(&builder); |
660 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
661 | if (!scope.ok()) return; |
662 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
663 | this->operation = Operation(ret); |
664 | this->output = Output(ret, 0); |
665 | } |
666 | |
667 | Cos::Cos(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
668 | if (!scope.ok()) return; |
669 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
670 | if (!scope.ok()) return; |
671 | ::tensorflow::Node* ret; |
672 | const auto unique_name = scope.GetUniqueNameForOp("Cos" ); |
673 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Cos" ) |
674 | .Input(_x) |
675 | ; |
676 | scope.UpdateBuilder(&builder); |
677 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
678 | if (!scope.ok()) return; |
679 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
680 | this->operation = Operation(ret); |
681 | this->y = Output(ret, 0); |
682 | } |
683 | |
684 | Cosh::Cosh(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
685 | if (!scope.ok()) return; |
686 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
687 | if (!scope.ok()) return; |
688 | ::tensorflow::Node* ret; |
689 | const auto unique_name = scope.GetUniqueNameForOp("Cosh" ); |
690 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Cosh" ) |
691 | .Input(_x) |
692 | ; |
693 | scope.UpdateBuilder(&builder); |
694 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
695 | if (!scope.ok()) return; |
696 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
697 | this->operation = Operation(ret); |
698 | this->y = Output(ret, 0); |
699 | } |
700 | |
701 | Cross::Cross(const ::tensorflow::Scope& scope, ::tensorflow::Input a, |
702 | ::tensorflow::Input b) { |
703 | if (!scope.ok()) return; |
704 | auto _a = ::tensorflow::ops::AsNodeOut(scope, a); |
705 | if (!scope.ok()) return; |
706 | auto _b = ::tensorflow::ops::AsNodeOut(scope, b); |
707 | if (!scope.ok()) return; |
708 | ::tensorflow::Node* ret; |
709 | const auto unique_name = scope.GetUniqueNameForOp("Cross" ); |
710 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Cross" ) |
711 | .Input(_a) |
712 | .Input(_b) |
713 | ; |
714 | scope.UpdateBuilder(&builder); |
715 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
716 | if (!scope.ok()) return; |
717 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
718 | this->operation = Operation(ret); |
719 | this->product = Output(ret, 0); |
720 | } |
721 | |
722 | Cumprod::Cumprod(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
723 | ::tensorflow::Input axis, const Cumprod::Attrs& attrs) { |
724 | if (!scope.ok()) return; |
725 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
726 | if (!scope.ok()) return; |
727 | auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis); |
728 | if (!scope.ok()) return; |
729 | ::tensorflow::Node* ret; |
730 | const auto unique_name = scope.GetUniqueNameForOp("Cumprod" ); |
731 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Cumprod" ) |
732 | .Input(_x) |
733 | .Input(_axis) |
734 | .Attr("exclusive" , attrs.exclusive_) |
735 | .Attr("reverse" , attrs.reverse_) |
736 | ; |
737 | scope.UpdateBuilder(&builder); |
738 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
739 | if (!scope.ok()) return; |
740 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
741 | this->operation = Operation(ret); |
742 | this->out = Output(ret, 0); |
743 | } |
744 | |
745 | Cumprod::Cumprod(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
746 | ::tensorflow::Input axis) |
747 | : Cumprod(scope, x, axis, Cumprod::Attrs()) {} |
748 | |
749 | Cumsum::Cumsum(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
750 | ::tensorflow::Input axis, const Cumsum::Attrs& attrs) { |
751 | if (!scope.ok()) return; |
752 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
753 | if (!scope.ok()) return; |
754 | auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis); |
755 | if (!scope.ok()) return; |
756 | ::tensorflow::Node* ret; |
757 | const auto unique_name = scope.GetUniqueNameForOp("Cumsum" ); |
758 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Cumsum" ) |
759 | .Input(_x) |
760 | .Input(_axis) |
761 | .Attr("exclusive" , attrs.exclusive_) |
762 | .Attr("reverse" , attrs.reverse_) |
763 | ; |
764 | scope.UpdateBuilder(&builder); |
765 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
766 | if (!scope.ok()) return; |
767 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
768 | this->operation = Operation(ret); |
769 | this->out = Output(ret, 0); |
770 | } |
771 | |
772 | Cumsum::Cumsum(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
773 | ::tensorflow::Input axis) |
774 | : Cumsum(scope, x, axis, Cumsum::Attrs()) {} |
775 | |
776 | DenseBincount::DenseBincount(const ::tensorflow::Scope& scope, |
777 | ::tensorflow::Input input, ::tensorflow::Input |
778 | size, ::tensorflow::Input weights, const |
779 | DenseBincount::Attrs& attrs) { |
780 | if (!scope.ok()) return; |
781 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
782 | if (!scope.ok()) return; |
783 | auto _size = ::tensorflow::ops::AsNodeOut(scope, size); |
784 | if (!scope.ok()) return; |
785 | auto _weights = ::tensorflow::ops::AsNodeOut(scope, weights); |
786 | if (!scope.ok()) return; |
787 | ::tensorflow::Node* ret; |
788 | const auto unique_name = scope.GetUniqueNameForOp("DenseBincount" ); |
789 | auto builder = ::tensorflow::NodeBuilder(unique_name, "DenseBincount" ) |
790 | .Input(_input) |
791 | .Input(_size) |
792 | .Input(_weights) |
793 | .Attr("binary_output" , attrs.binary_output_) |
794 | ; |
795 | scope.UpdateBuilder(&builder); |
796 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
797 | if (!scope.ok()) return; |
798 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
799 | this->operation = Operation(ret); |
800 | this->output = Output(ret, 0); |
801 | } |
802 | |
803 | DenseBincount::DenseBincount(const ::tensorflow::Scope& scope, |
804 | ::tensorflow::Input input, ::tensorflow::Input |
805 | size, ::tensorflow::Input weights) |
806 | : DenseBincount(scope, input, size, weights, DenseBincount::Attrs()) {} |
807 | |
808 | Digamma::Digamma(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
809 | if (!scope.ok()) return; |
810 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
811 | if (!scope.ok()) return; |
812 | ::tensorflow::Node* ret; |
813 | const auto unique_name = scope.GetUniqueNameForOp("Digamma" ); |
814 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Digamma" ) |
815 | .Input(_x) |
816 | ; |
817 | scope.UpdateBuilder(&builder); |
818 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
819 | if (!scope.ok()) return; |
820 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
821 | this->operation = Operation(ret); |
822 | this->y = Output(ret, 0); |
823 | } |
824 | |
825 | Div::Div(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
826 | ::tensorflow::Input y) { |
827 | if (!scope.ok()) return; |
828 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
829 | if (!scope.ok()) return; |
830 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
831 | if (!scope.ok()) return; |
832 | ::tensorflow::Node* ret; |
833 | const auto unique_name = scope.GetUniqueNameForOp("Div" ); |
834 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Div" ) |
835 | .Input(_x) |
836 | .Input(_y) |
837 | ; |
838 | scope.UpdateBuilder(&builder); |
839 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
840 | if (!scope.ok()) return; |
841 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
842 | this->operation = Operation(ret); |
843 | this->z = Output(ret, 0); |
844 | } |
845 | |
846 | DivNoNan::DivNoNan(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
847 | ::tensorflow::Input y) { |
848 | if (!scope.ok()) return; |
849 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
850 | if (!scope.ok()) return; |
851 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
852 | if (!scope.ok()) return; |
853 | ::tensorflow::Node* ret; |
854 | const auto unique_name = scope.GetUniqueNameForOp("DivNoNan" ); |
855 | auto builder = ::tensorflow::NodeBuilder(unique_name, "DivNoNan" ) |
856 | .Input(_x) |
857 | .Input(_y) |
858 | ; |
859 | scope.UpdateBuilder(&builder); |
860 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
861 | if (!scope.ok()) return; |
862 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
863 | this->operation = Operation(ret); |
864 | this->z = Output(ret, 0); |
865 | } |
866 | |
867 | Equal::Equal(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
868 | ::tensorflow::Input y, const Equal::Attrs& attrs) { |
869 | if (!scope.ok()) return; |
870 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
871 | if (!scope.ok()) return; |
872 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
873 | if (!scope.ok()) return; |
874 | ::tensorflow::Node* ret; |
875 | const auto unique_name = scope.GetUniqueNameForOp("Equal" ); |
876 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Equal" ) |
877 | .Input(_x) |
878 | .Input(_y) |
879 | .Attr("incompatible_shape_error" , attrs.incompatible_shape_error_) |
880 | ; |
881 | scope.UpdateBuilder(&builder); |
882 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
883 | if (!scope.ok()) return; |
884 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
885 | this->operation = Operation(ret); |
886 | this->z = Output(ret, 0); |
887 | } |
888 | |
889 | Equal::Equal(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
890 | ::tensorflow::Input y) |
891 | : Equal(scope, x, y, Equal::Attrs()) {} |
892 | |
893 | Erf::Erf(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
894 | if (!scope.ok()) return; |
895 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
896 | if (!scope.ok()) return; |
897 | ::tensorflow::Node* ret; |
898 | const auto unique_name = scope.GetUniqueNameForOp("Erf" ); |
899 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Erf" ) |
900 | .Input(_x) |
901 | ; |
902 | scope.UpdateBuilder(&builder); |
903 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
904 | if (!scope.ok()) return; |
905 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
906 | this->operation = Operation(ret); |
907 | this->y = Output(ret, 0); |
908 | } |
909 | |
910 | Erfc::Erfc(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
911 | if (!scope.ok()) return; |
912 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
913 | if (!scope.ok()) return; |
914 | ::tensorflow::Node* ret; |
915 | const auto unique_name = scope.GetUniqueNameForOp("Erfc" ); |
916 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Erfc" ) |
917 | .Input(_x) |
918 | ; |
919 | scope.UpdateBuilder(&builder); |
920 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
921 | if (!scope.ok()) return; |
922 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
923 | this->operation = Operation(ret); |
924 | this->y = Output(ret, 0); |
925 | } |
926 | |
927 | Erfinv::Erfinv(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
928 | if (!scope.ok()) return; |
929 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
930 | if (!scope.ok()) return; |
931 | ::tensorflow::Node* ret; |
932 | const auto unique_name = scope.GetUniqueNameForOp("Erfinv" ); |
933 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Erfinv" ) |
934 | .Input(_x) |
935 | ; |
936 | scope.UpdateBuilder(&builder); |
937 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
938 | if (!scope.ok()) return; |
939 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
940 | this->operation = Operation(ret); |
941 | this->y = Output(ret, 0); |
942 | } |
943 | |
944 | EuclideanNorm::EuclideanNorm(const ::tensorflow::Scope& scope, |
945 | ::tensorflow::Input input, ::tensorflow::Input |
946 | axis, const EuclideanNorm::Attrs& attrs) { |
947 | if (!scope.ok()) return; |
948 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
949 | if (!scope.ok()) return; |
950 | auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis); |
951 | if (!scope.ok()) return; |
952 | ::tensorflow::Node* ret; |
953 | const auto unique_name = scope.GetUniqueNameForOp("EuclideanNorm" ); |
954 | auto builder = ::tensorflow::NodeBuilder(unique_name, "EuclideanNorm" ) |
955 | .Input(_input) |
956 | .Input(_axis) |
957 | .Attr("keep_dims" , attrs.keep_dims_) |
958 | ; |
959 | scope.UpdateBuilder(&builder); |
960 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
961 | if (!scope.ok()) return; |
962 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
963 | this->operation = Operation(ret); |
964 | this->output = Output(ret, 0); |
965 | } |
966 | |
967 | EuclideanNorm::EuclideanNorm(const ::tensorflow::Scope& scope, |
968 | ::tensorflow::Input input, ::tensorflow::Input |
969 | axis) |
970 | : EuclideanNorm(scope, input, axis, EuclideanNorm::Attrs()) {} |
971 | |
972 | Exp::Exp(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
973 | if (!scope.ok()) return; |
974 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
975 | if (!scope.ok()) return; |
976 | ::tensorflow::Node* ret; |
977 | const auto unique_name = scope.GetUniqueNameForOp("Exp" ); |
978 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Exp" ) |
979 | .Input(_x) |
980 | ; |
981 | scope.UpdateBuilder(&builder); |
982 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
983 | if (!scope.ok()) return; |
984 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
985 | this->operation = Operation(ret); |
986 | this->y = Output(ret, 0); |
987 | } |
988 | |
989 | Expm1::Expm1(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
990 | if (!scope.ok()) return; |
991 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
992 | if (!scope.ok()) return; |
993 | ::tensorflow::Node* ret; |
994 | const auto unique_name = scope.GetUniqueNameForOp("Expm1" ); |
995 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Expm1" ) |
996 | .Input(_x) |
997 | ; |
998 | scope.UpdateBuilder(&builder); |
999 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1000 | if (!scope.ok()) return; |
1001 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1002 | this->operation = Operation(ret); |
1003 | this->y = Output(ret, 0); |
1004 | } |
1005 | |
1006 | Floor::Floor(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
1007 | if (!scope.ok()) return; |
1008 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1009 | if (!scope.ok()) return; |
1010 | ::tensorflow::Node* ret; |
1011 | const auto unique_name = scope.GetUniqueNameForOp("Floor" ); |
1012 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Floor" ) |
1013 | .Input(_x) |
1014 | ; |
1015 | scope.UpdateBuilder(&builder); |
1016 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1017 | if (!scope.ok()) return; |
1018 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1019 | this->operation = Operation(ret); |
1020 | this->y = Output(ret, 0); |
1021 | } |
1022 | |
1023 | FloorDiv::FloorDiv(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1024 | ::tensorflow::Input y) { |
1025 | if (!scope.ok()) return; |
1026 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1027 | if (!scope.ok()) return; |
1028 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1029 | if (!scope.ok()) return; |
1030 | ::tensorflow::Node* ret; |
1031 | const auto unique_name = scope.GetUniqueNameForOp("FloorDiv" ); |
1032 | auto builder = ::tensorflow::NodeBuilder(unique_name, "FloorDiv" ) |
1033 | .Input(_x) |
1034 | .Input(_y) |
1035 | ; |
1036 | scope.UpdateBuilder(&builder); |
1037 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1038 | if (!scope.ok()) return; |
1039 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1040 | this->operation = Operation(ret); |
1041 | this->z = Output(ret, 0); |
1042 | } |
1043 | |
1044 | FloorMod::FloorMod(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1045 | ::tensorflow::Input y) { |
1046 | if (!scope.ok()) return; |
1047 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1048 | if (!scope.ok()) return; |
1049 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1050 | if (!scope.ok()) return; |
1051 | ::tensorflow::Node* ret; |
1052 | const auto unique_name = scope.GetUniqueNameForOp("FloorMod" ); |
1053 | auto builder = ::tensorflow::NodeBuilder(unique_name, "FloorMod" ) |
1054 | .Input(_x) |
1055 | .Input(_y) |
1056 | ; |
1057 | scope.UpdateBuilder(&builder); |
1058 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1059 | if (!scope.ok()) return; |
1060 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1061 | this->operation = Operation(ret); |
1062 | this->z = Output(ret, 0); |
1063 | } |
1064 | |
1065 | Greater::Greater(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1066 | ::tensorflow::Input y) { |
1067 | if (!scope.ok()) return; |
1068 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1069 | if (!scope.ok()) return; |
1070 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1071 | if (!scope.ok()) return; |
1072 | ::tensorflow::Node* ret; |
1073 | const auto unique_name = scope.GetUniqueNameForOp("Greater" ); |
1074 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Greater" ) |
1075 | .Input(_x) |
1076 | .Input(_y) |
1077 | ; |
1078 | scope.UpdateBuilder(&builder); |
1079 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1080 | if (!scope.ok()) return; |
1081 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1082 | this->operation = Operation(ret); |
1083 | this->z = Output(ret, 0); |
1084 | } |
1085 | |
1086 | GreaterEqual::GreaterEqual(const ::tensorflow::Scope& scope, |
1087 | ::tensorflow::Input x, ::tensorflow::Input y) { |
1088 | if (!scope.ok()) return; |
1089 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1090 | if (!scope.ok()) return; |
1091 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1092 | if (!scope.ok()) return; |
1093 | ::tensorflow::Node* ret; |
1094 | const auto unique_name = scope.GetUniqueNameForOp("GreaterEqual" ); |
1095 | auto builder = ::tensorflow::NodeBuilder(unique_name, "GreaterEqual" ) |
1096 | .Input(_x) |
1097 | .Input(_y) |
1098 | ; |
1099 | scope.UpdateBuilder(&builder); |
1100 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1101 | if (!scope.ok()) return; |
1102 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1103 | this->operation = Operation(ret); |
1104 | this->z = Output(ret, 0); |
1105 | } |
1106 | |
1107 | HistogramFixedWidth::HistogramFixedWidth(const ::tensorflow::Scope& scope, |
1108 | ::tensorflow::Input values, |
1109 | ::tensorflow::Input value_range, |
1110 | ::tensorflow::Input nbins, const |
1111 | HistogramFixedWidth::Attrs& attrs) { |
1112 | if (!scope.ok()) return; |
1113 | auto _values = ::tensorflow::ops::AsNodeOut(scope, values); |
1114 | if (!scope.ok()) return; |
1115 | auto _value_range = ::tensorflow::ops::AsNodeOut(scope, value_range); |
1116 | if (!scope.ok()) return; |
1117 | auto _nbins = ::tensorflow::ops::AsNodeOut(scope, nbins); |
1118 | if (!scope.ok()) return; |
1119 | ::tensorflow::Node* ret; |
1120 | const auto unique_name = scope.GetUniqueNameForOp("HistogramFixedWidth" ); |
1121 | auto builder = ::tensorflow::NodeBuilder(unique_name, "HistogramFixedWidth" ) |
1122 | .Input(_values) |
1123 | .Input(_value_range) |
1124 | .Input(_nbins) |
1125 | .Attr("dtype" , attrs.dtype_) |
1126 | ; |
1127 | scope.UpdateBuilder(&builder); |
1128 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1129 | if (!scope.ok()) return; |
1130 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1131 | this->operation = Operation(ret); |
1132 | this->out = Output(ret, 0); |
1133 | } |
1134 | |
1135 | HistogramFixedWidth::HistogramFixedWidth(const ::tensorflow::Scope& scope, |
1136 | ::tensorflow::Input values, |
1137 | ::tensorflow::Input value_range, |
1138 | ::tensorflow::Input nbins) |
1139 | : HistogramFixedWidth(scope, values, value_range, nbins, HistogramFixedWidth::Attrs()) {} |
1140 | |
1141 | Igamma::Igamma(const ::tensorflow::Scope& scope, ::tensorflow::Input a, |
1142 | ::tensorflow::Input x) { |
1143 | if (!scope.ok()) return; |
1144 | auto _a = ::tensorflow::ops::AsNodeOut(scope, a); |
1145 | if (!scope.ok()) return; |
1146 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1147 | if (!scope.ok()) return; |
1148 | ::tensorflow::Node* ret; |
1149 | const auto unique_name = scope.GetUniqueNameForOp("Igamma" ); |
1150 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Igamma" ) |
1151 | .Input(_a) |
1152 | .Input(_x) |
1153 | ; |
1154 | scope.UpdateBuilder(&builder); |
1155 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1156 | if (!scope.ok()) return; |
1157 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1158 | this->operation = Operation(ret); |
1159 | this->z = Output(ret, 0); |
1160 | } |
1161 | |
1162 | Igammac::Igammac(const ::tensorflow::Scope& scope, ::tensorflow::Input a, |
1163 | ::tensorflow::Input x) { |
1164 | if (!scope.ok()) return; |
1165 | auto _a = ::tensorflow::ops::AsNodeOut(scope, a); |
1166 | if (!scope.ok()) return; |
1167 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1168 | if (!scope.ok()) return; |
1169 | ::tensorflow::Node* ret; |
1170 | const auto unique_name = scope.GetUniqueNameForOp("Igammac" ); |
1171 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Igammac" ) |
1172 | .Input(_a) |
1173 | .Input(_x) |
1174 | ; |
1175 | scope.UpdateBuilder(&builder); |
1176 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1177 | if (!scope.ok()) return; |
1178 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1179 | this->operation = Operation(ret); |
1180 | this->z = Output(ret, 0); |
1181 | } |
1182 | |
1183 | Imag::Imag(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const |
1184 | Imag::Attrs& attrs) { |
1185 | if (!scope.ok()) return; |
1186 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
1187 | if (!scope.ok()) return; |
1188 | ::tensorflow::Node* ret; |
1189 | const auto unique_name = scope.GetUniqueNameForOp("Imag" ); |
1190 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Imag" ) |
1191 | .Input(_input) |
1192 | .Attr("Tout" , attrs.Tout_) |
1193 | ; |
1194 | scope.UpdateBuilder(&builder); |
1195 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1196 | if (!scope.ok()) return; |
1197 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1198 | this->operation = Operation(ret); |
1199 | this->output = Output(ret, 0); |
1200 | } |
1201 | |
1202 | Imag::Imag(const ::tensorflow::Scope& scope, ::tensorflow::Input input) |
1203 | : Imag(scope, input, Imag::Attrs()) {} |
1204 | |
1205 | Inv::Inv(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
1206 | if (!scope.ok()) return; |
1207 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1208 | if (!scope.ok()) return; |
1209 | ::tensorflow::Node* ret; |
1210 | const auto unique_name = scope.GetUniqueNameForOp("Inv" ); |
1211 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Inv" ) |
1212 | .Input(_x) |
1213 | ; |
1214 | scope.UpdateBuilder(&builder); |
1215 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1216 | if (!scope.ok()) return; |
1217 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1218 | this->operation = Operation(ret); |
1219 | this->y = Output(ret, 0); |
1220 | } |
1221 | |
1222 | IsFinite::IsFinite(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
1223 | if (!scope.ok()) return; |
1224 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1225 | if (!scope.ok()) return; |
1226 | ::tensorflow::Node* ret; |
1227 | const auto unique_name = scope.GetUniqueNameForOp("IsFinite" ); |
1228 | auto builder = ::tensorflow::NodeBuilder(unique_name, "IsFinite" ) |
1229 | .Input(_x) |
1230 | ; |
1231 | scope.UpdateBuilder(&builder); |
1232 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1233 | if (!scope.ok()) return; |
1234 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1235 | this->operation = Operation(ret); |
1236 | this->y = Output(ret, 0); |
1237 | } |
1238 | |
1239 | IsInf::IsInf(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
1240 | if (!scope.ok()) return; |
1241 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1242 | if (!scope.ok()) return; |
1243 | ::tensorflow::Node* ret; |
1244 | const auto unique_name = scope.GetUniqueNameForOp("IsInf" ); |
1245 | auto builder = ::tensorflow::NodeBuilder(unique_name, "IsInf" ) |
1246 | .Input(_x) |
1247 | ; |
1248 | scope.UpdateBuilder(&builder); |
1249 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1250 | if (!scope.ok()) return; |
1251 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1252 | this->operation = Operation(ret); |
1253 | this->y = Output(ret, 0); |
1254 | } |
1255 | |
1256 | IsNan::IsNan(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
1257 | if (!scope.ok()) return; |
1258 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1259 | if (!scope.ok()) return; |
1260 | ::tensorflow::Node* ret; |
1261 | const auto unique_name = scope.GetUniqueNameForOp("IsNan" ); |
1262 | auto builder = ::tensorflow::NodeBuilder(unique_name, "IsNan" ) |
1263 | .Input(_x) |
1264 | ; |
1265 | scope.UpdateBuilder(&builder); |
1266 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1267 | if (!scope.ok()) return; |
1268 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1269 | this->operation = Operation(ret); |
1270 | this->y = Output(ret, 0); |
1271 | } |
1272 | |
1273 | Less::Less(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1274 | ::tensorflow::Input y) { |
1275 | if (!scope.ok()) return; |
1276 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1277 | if (!scope.ok()) return; |
1278 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1279 | if (!scope.ok()) return; |
1280 | ::tensorflow::Node* ret; |
1281 | const auto unique_name = scope.GetUniqueNameForOp("Less" ); |
1282 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Less" ) |
1283 | .Input(_x) |
1284 | .Input(_y) |
1285 | ; |
1286 | scope.UpdateBuilder(&builder); |
1287 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1288 | if (!scope.ok()) return; |
1289 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1290 | this->operation = Operation(ret); |
1291 | this->z = Output(ret, 0); |
1292 | } |
1293 | |
1294 | LessEqual::LessEqual(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1295 | ::tensorflow::Input y) { |
1296 | if (!scope.ok()) return; |
1297 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1298 | if (!scope.ok()) return; |
1299 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1300 | if (!scope.ok()) return; |
1301 | ::tensorflow::Node* ret; |
1302 | const auto unique_name = scope.GetUniqueNameForOp("LessEqual" ); |
1303 | auto builder = ::tensorflow::NodeBuilder(unique_name, "LessEqual" ) |
1304 | .Input(_x) |
1305 | .Input(_y) |
1306 | ; |
1307 | scope.UpdateBuilder(&builder); |
1308 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1309 | if (!scope.ok()) return; |
1310 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1311 | this->operation = Operation(ret); |
1312 | this->z = Output(ret, 0); |
1313 | } |
1314 | |
1315 | Lgamma::Lgamma(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
1316 | if (!scope.ok()) return; |
1317 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1318 | if (!scope.ok()) return; |
1319 | ::tensorflow::Node* ret; |
1320 | const auto unique_name = scope.GetUniqueNameForOp("Lgamma" ); |
1321 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Lgamma" ) |
1322 | .Input(_x) |
1323 | ; |
1324 | scope.UpdateBuilder(&builder); |
1325 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1326 | if (!scope.ok()) return; |
1327 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1328 | this->operation = Operation(ret); |
1329 | this->y = Output(ret, 0); |
1330 | } |
1331 | |
1332 | Log::Log(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
1333 | if (!scope.ok()) return; |
1334 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1335 | if (!scope.ok()) return; |
1336 | ::tensorflow::Node* ret; |
1337 | const auto unique_name = scope.GetUniqueNameForOp("Log" ); |
1338 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Log" ) |
1339 | .Input(_x) |
1340 | ; |
1341 | scope.UpdateBuilder(&builder); |
1342 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1343 | if (!scope.ok()) return; |
1344 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1345 | this->operation = Operation(ret); |
1346 | this->y = Output(ret, 0); |
1347 | } |
1348 | |
1349 | Log1p::Log1p(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
1350 | if (!scope.ok()) return; |
1351 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1352 | if (!scope.ok()) return; |
1353 | ::tensorflow::Node* ret; |
1354 | const auto unique_name = scope.GetUniqueNameForOp("Log1p" ); |
1355 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Log1p" ) |
1356 | .Input(_x) |
1357 | ; |
1358 | scope.UpdateBuilder(&builder); |
1359 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1360 | if (!scope.ok()) return; |
1361 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1362 | this->operation = Operation(ret); |
1363 | this->y = Output(ret, 0); |
1364 | } |
1365 | |
1366 | LogicalAnd::LogicalAnd(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1367 | ::tensorflow::Input y) { |
1368 | if (!scope.ok()) return; |
1369 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1370 | if (!scope.ok()) return; |
1371 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1372 | if (!scope.ok()) return; |
1373 | ::tensorflow::Node* ret; |
1374 | const auto unique_name = scope.GetUniqueNameForOp("LogicalAnd" ); |
1375 | auto builder = ::tensorflow::NodeBuilder(unique_name, "LogicalAnd" ) |
1376 | .Input(_x) |
1377 | .Input(_y) |
1378 | ; |
1379 | scope.UpdateBuilder(&builder); |
1380 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1381 | if (!scope.ok()) return; |
1382 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1383 | this->operation = Operation(ret); |
1384 | this->z = Output(ret, 0); |
1385 | } |
1386 | |
1387 | LogicalNot::LogicalNot(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
1388 | if (!scope.ok()) return; |
1389 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1390 | if (!scope.ok()) return; |
1391 | ::tensorflow::Node* ret; |
1392 | const auto unique_name = scope.GetUniqueNameForOp("LogicalNot" ); |
1393 | auto builder = ::tensorflow::NodeBuilder(unique_name, "LogicalNot" ) |
1394 | .Input(_x) |
1395 | ; |
1396 | scope.UpdateBuilder(&builder); |
1397 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1398 | if (!scope.ok()) return; |
1399 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1400 | this->operation = Operation(ret); |
1401 | this->y = Output(ret, 0); |
1402 | } |
1403 | |
1404 | LogicalOr::LogicalOr(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1405 | ::tensorflow::Input y) { |
1406 | if (!scope.ok()) return; |
1407 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1408 | if (!scope.ok()) return; |
1409 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1410 | if (!scope.ok()) return; |
1411 | ::tensorflow::Node* ret; |
1412 | const auto unique_name = scope.GetUniqueNameForOp("LogicalOr" ); |
1413 | auto builder = ::tensorflow::NodeBuilder(unique_name, "LogicalOr" ) |
1414 | .Input(_x) |
1415 | .Input(_y) |
1416 | ; |
1417 | scope.UpdateBuilder(&builder); |
1418 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1419 | if (!scope.ok()) return; |
1420 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1421 | this->operation = Operation(ret); |
1422 | this->z = Output(ret, 0); |
1423 | } |
1424 | |
1425 | MatMul::MatMul(const ::tensorflow::Scope& scope, ::tensorflow::Input a, |
1426 | ::tensorflow::Input b, const MatMul::Attrs& attrs) { |
1427 | if (!scope.ok()) return; |
1428 | auto _a = ::tensorflow::ops::AsNodeOut(scope, a); |
1429 | if (!scope.ok()) return; |
1430 | auto _b = ::tensorflow::ops::AsNodeOut(scope, b); |
1431 | if (!scope.ok()) return; |
1432 | ::tensorflow::Node* ret; |
1433 | const auto unique_name = scope.GetUniqueNameForOp("MatMul" ); |
1434 | auto builder = ::tensorflow::NodeBuilder(unique_name, "MatMul" ) |
1435 | .Input(_a) |
1436 | .Input(_b) |
1437 | .Attr("transpose_a" , attrs.transpose_a_) |
1438 | .Attr("transpose_b" , attrs.transpose_b_) |
1439 | ; |
1440 | scope.UpdateBuilder(&builder); |
1441 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1442 | if (!scope.ok()) return; |
1443 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1444 | this->operation = Operation(ret); |
1445 | this->product = Output(ret, 0); |
1446 | } |
1447 | |
1448 | MatMul::MatMul(const ::tensorflow::Scope& scope, ::tensorflow::Input a, |
1449 | ::tensorflow::Input b) |
1450 | : MatMul(scope, a, b, MatMul::Attrs()) {} |
1451 | |
1452 | Max::Max(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
1453 | ::tensorflow::Input axis, const Max::Attrs& attrs) { |
1454 | if (!scope.ok()) return; |
1455 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
1456 | if (!scope.ok()) return; |
1457 | auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis); |
1458 | if (!scope.ok()) return; |
1459 | ::tensorflow::Node* ret; |
1460 | const auto unique_name = scope.GetUniqueNameForOp("Max" ); |
1461 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Max" ) |
1462 | .Input(_input) |
1463 | .Input(_axis) |
1464 | .Attr("keep_dims" , attrs.keep_dims_) |
1465 | ; |
1466 | scope.UpdateBuilder(&builder); |
1467 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1468 | if (!scope.ok()) return; |
1469 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1470 | this->operation = Operation(ret); |
1471 | this->output = Output(ret, 0); |
1472 | } |
1473 | |
1474 | Max::Max(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
1475 | ::tensorflow::Input axis) |
1476 | : Max(scope, input, axis, Max::Attrs()) {} |
1477 | |
1478 | Maximum::Maximum(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1479 | ::tensorflow::Input y) { |
1480 | if (!scope.ok()) return; |
1481 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1482 | if (!scope.ok()) return; |
1483 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1484 | if (!scope.ok()) return; |
1485 | ::tensorflow::Node* ret; |
1486 | const auto unique_name = scope.GetUniqueNameForOp("Maximum" ); |
1487 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Maximum" ) |
1488 | .Input(_x) |
1489 | .Input(_y) |
1490 | ; |
1491 | scope.UpdateBuilder(&builder); |
1492 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1493 | if (!scope.ok()) return; |
1494 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1495 | this->operation = Operation(ret); |
1496 | this->z = Output(ret, 0); |
1497 | } |
1498 | |
1499 | Mean::Mean(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
1500 | ::tensorflow::Input axis, const Mean::Attrs& attrs) { |
1501 | if (!scope.ok()) return; |
1502 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
1503 | if (!scope.ok()) return; |
1504 | auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis); |
1505 | if (!scope.ok()) return; |
1506 | ::tensorflow::Node* ret; |
1507 | const auto unique_name = scope.GetUniqueNameForOp("Mean" ); |
1508 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Mean" ) |
1509 | .Input(_input) |
1510 | .Input(_axis) |
1511 | .Attr("keep_dims" , attrs.keep_dims_) |
1512 | ; |
1513 | scope.UpdateBuilder(&builder); |
1514 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1515 | if (!scope.ok()) return; |
1516 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1517 | this->operation = Operation(ret); |
1518 | this->output = Output(ret, 0); |
1519 | } |
1520 | |
1521 | Mean::Mean(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
1522 | ::tensorflow::Input axis) |
1523 | : Mean(scope, input, axis, Mean::Attrs()) {} |
1524 | |
1525 | Min::Min(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
1526 | ::tensorflow::Input axis, const Min::Attrs& attrs) { |
1527 | if (!scope.ok()) return; |
1528 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
1529 | if (!scope.ok()) return; |
1530 | auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis); |
1531 | if (!scope.ok()) return; |
1532 | ::tensorflow::Node* ret; |
1533 | const auto unique_name = scope.GetUniqueNameForOp("Min" ); |
1534 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Min" ) |
1535 | .Input(_input) |
1536 | .Input(_axis) |
1537 | .Attr("keep_dims" , attrs.keep_dims_) |
1538 | ; |
1539 | scope.UpdateBuilder(&builder); |
1540 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1541 | if (!scope.ok()) return; |
1542 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1543 | this->operation = Operation(ret); |
1544 | this->output = Output(ret, 0); |
1545 | } |
1546 | |
1547 | Min::Min(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
1548 | ::tensorflow::Input axis) |
1549 | : Min(scope, input, axis, Min::Attrs()) {} |
1550 | |
1551 | Minimum::Minimum(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1552 | ::tensorflow::Input y) { |
1553 | if (!scope.ok()) return; |
1554 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1555 | if (!scope.ok()) return; |
1556 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1557 | if (!scope.ok()) return; |
1558 | ::tensorflow::Node* ret; |
1559 | const auto unique_name = scope.GetUniqueNameForOp("Minimum" ); |
1560 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Minimum" ) |
1561 | .Input(_x) |
1562 | .Input(_y) |
1563 | ; |
1564 | scope.UpdateBuilder(&builder); |
1565 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1566 | if (!scope.ok()) return; |
1567 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1568 | this->operation = Operation(ret); |
1569 | this->z = Output(ret, 0); |
1570 | } |
1571 | |
1572 | Mod::Mod(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1573 | ::tensorflow::Input y) { |
1574 | if (!scope.ok()) return; |
1575 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1576 | if (!scope.ok()) return; |
1577 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1578 | if (!scope.ok()) return; |
1579 | ::tensorflow::Node* ret; |
1580 | const auto unique_name = scope.GetUniqueNameForOp("Mod" ); |
1581 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Mod" ) |
1582 | .Input(_x) |
1583 | .Input(_y) |
1584 | ; |
1585 | scope.UpdateBuilder(&builder); |
1586 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1587 | if (!scope.ok()) return; |
1588 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1589 | this->operation = Operation(ret); |
1590 | this->z = Output(ret, 0); |
1591 | } |
1592 | |
1593 | Multiply::Multiply(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1594 | ::tensorflow::Input y) { |
1595 | if (!scope.ok()) return; |
1596 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1597 | if (!scope.ok()) return; |
1598 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1599 | if (!scope.ok()) return; |
1600 | ::tensorflow::Node* ret; |
1601 | const auto unique_name = scope.GetUniqueNameForOp("Multiply" ); |
1602 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Mul" ) |
1603 | .Input(_x) |
1604 | .Input(_y) |
1605 | ; |
1606 | scope.UpdateBuilder(&builder); |
1607 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1608 | if (!scope.ok()) return; |
1609 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1610 | this->operation = Operation(ret); |
1611 | this->z = Output(ret, 0); |
1612 | } |
1613 | |
1614 | MulNoNan::MulNoNan(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1615 | ::tensorflow::Input y) { |
1616 | if (!scope.ok()) return; |
1617 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1618 | if (!scope.ok()) return; |
1619 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1620 | if (!scope.ok()) return; |
1621 | ::tensorflow::Node* ret; |
1622 | const auto unique_name = scope.GetUniqueNameForOp("MulNoNan" ); |
1623 | auto builder = ::tensorflow::NodeBuilder(unique_name, "MulNoNan" ) |
1624 | .Input(_x) |
1625 | .Input(_y) |
1626 | ; |
1627 | scope.UpdateBuilder(&builder); |
1628 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1629 | if (!scope.ok()) return; |
1630 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1631 | this->operation = Operation(ret); |
1632 | this->z = Output(ret, 0); |
1633 | } |
1634 | |
1635 | Ndtri::Ndtri(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
1636 | if (!scope.ok()) return; |
1637 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1638 | if (!scope.ok()) return; |
1639 | ::tensorflow::Node* ret; |
1640 | const auto unique_name = scope.GetUniqueNameForOp("Ndtri" ); |
1641 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Ndtri" ) |
1642 | .Input(_x) |
1643 | ; |
1644 | scope.UpdateBuilder(&builder); |
1645 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1646 | if (!scope.ok()) return; |
1647 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1648 | this->operation = Operation(ret); |
1649 | this->y = Output(ret, 0); |
1650 | } |
1651 | |
1652 | Negate::Negate(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
1653 | if (!scope.ok()) return; |
1654 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1655 | if (!scope.ok()) return; |
1656 | ::tensorflow::Node* ret; |
1657 | const auto unique_name = scope.GetUniqueNameForOp("Negate" ); |
1658 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Neg" ) |
1659 | .Input(_x) |
1660 | ; |
1661 | scope.UpdateBuilder(&builder); |
1662 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1663 | if (!scope.ok()) return; |
1664 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1665 | this->operation = Operation(ret); |
1666 | this->y = Output(ret, 0); |
1667 | } |
1668 | |
1669 | NextAfter::NextAfter(const ::tensorflow::Scope& scope, ::tensorflow::Input x1, |
1670 | ::tensorflow::Input x2) { |
1671 | if (!scope.ok()) return; |
1672 | auto _x1 = ::tensorflow::ops::AsNodeOut(scope, x1); |
1673 | if (!scope.ok()) return; |
1674 | auto _x2 = ::tensorflow::ops::AsNodeOut(scope, x2); |
1675 | if (!scope.ok()) return; |
1676 | ::tensorflow::Node* ret; |
1677 | const auto unique_name = scope.GetUniqueNameForOp("NextAfter" ); |
1678 | auto builder = ::tensorflow::NodeBuilder(unique_name, "NextAfter" ) |
1679 | .Input(_x1) |
1680 | .Input(_x2) |
1681 | ; |
1682 | scope.UpdateBuilder(&builder); |
1683 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1684 | if (!scope.ok()) return; |
1685 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1686 | this->operation = Operation(ret); |
1687 | this->output = Output(ret, 0); |
1688 | } |
1689 | |
1690 | NotEqual::NotEqual(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1691 | ::tensorflow::Input y, const NotEqual::Attrs& attrs) { |
1692 | if (!scope.ok()) return; |
1693 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1694 | if (!scope.ok()) return; |
1695 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1696 | if (!scope.ok()) return; |
1697 | ::tensorflow::Node* ret; |
1698 | const auto unique_name = scope.GetUniqueNameForOp("NotEqual" ); |
1699 | auto builder = ::tensorflow::NodeBuilder(unique_name, "NotEqual" ) |
1700 | .Input(_x) |
1701 | .Input(_y) |
1702 | .Attr("incompatible_shape_error" , attrs.incompatible_shape_error_) |
1703 | ; |
1704 | scope.UpdateBuilder(&builder); |
1705 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1706 | if (!scope.ok()) return; |
1707 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1708 | this->operation = Operation(ret); |
1709 | this->z = Output(ret, 0); |
1710 | } |
1711 | |
1712 | NotEqual::NotEqual(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1713 | ::tensorflow::Input y) |
1714 | : NotEqual(scope, x, y, NotEqual::Attrs()) {} |
1715 | |
1716 | Polygamma::Polygamma(const ::tensorflow::Scope& scope, ::tensorflow::Input a, |
1717 | ::tensorflow::Input x) { |
1718 | if (!scope.ok()) return; |
1719 | auto _a = ::tensorflow::ops::AsNodeOut(scope, a); |
1720 | if (!scope.ok()) return; |
1721 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1722 | if (!scope.ok()) return; |
1723 | ::tensorflow::Node* ret; |
1724 | const auto unique_name = scope.GetUniqueNameForOp("Polygamma" ); |
1725 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Polygamma" ) |
1726 | .Input(_a) |
1727 | .Input(_x) |
1728 | ; |
1729 | scope.UpdateBuilder(&builder); |
1730 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1731 | if (!scope.ok()) return; |
1732 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1733 | this->operation = Operation(ret); |
1734 | this->z = Output(ret, 0); |
1735 | } |
1736 | |
1737 | Pow::Pow(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
1738 | ::tensorflow::Input y) { |
1739 | if (!scope.ok()) return; |
1740 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1741 | if (!scope.ok()) return; |
1742 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1743 | if (!scope.ok()) return; |
1744 | ::tensorflow::Node* ret; |
1745 | const auto unique_name = scope.GetUniqueNameForOp("Pow" ); |
1746 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Pow" ) |
1747 | .Input(_x) |
1748 | .Input(_y) |
1749 | ; |
1750 | scope.UpdateBuilder(&builder); |
1751 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1752 | if (!scope.ok()) return; |
1753 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1754 | this->operation = Operation(ret); |
1755 | this->z = Output(ret, 0); |
1756 | } |
1757 | |
1758 | Prod::Prod(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
1759 | ::tensorflow::Input axis, const Prod::Attrs& attrs) { |
1760 | if (!scope.ok()) return; |
1761 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
1762 | if (!scope.ok()) return; |
1763 | auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis); |
1764 | if (!scope.ok()) return; |
1765 | ::tensorflow::Node* ret; |
1766 | const auto unique_name = scope.GetUniqueNameForOp("Prod" ); |
1767 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Prod" ) |
1768 | .Input(_input) |
1769 | .Input(_axis) |
1770 | .Attr("keep_dims" , attrs.keep_dims_) |
1771 | ; |
1772 | scope.UpdateBuilder(&builder); |
1773 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1774 | if (!scope.ok()) return; |
1775 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1776 | this->operation = Operation(ret); |
1777 | this->output = Output(ret, 0); |
1778 | } |
1779 | |
1780 | Prod::Prod(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
1781 | ::tensorflow::Input axis) |
1782 | : Prod(scope, input, axis, Prod::Attrs()) {} |
1783 | |
1784 | QuantizeDownAndShrinkRange::QuantizeDownAndShrinkRange(const |
1785 | ::tensorflow::Scope& |
1786 | scope, |
1787 | ::tensorflow::Input |
1788 | input, |
1789 | ::tensorflow::Input |
1790 | input_min, |
1791 | ::tensorflow::Input |
1792 | input_max, DataType |
1793 | out_type) { |
1794 | if (!scope.ok()) return; |
1795 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
1796 | if (!scope.ok()) return; |
1797 | auto _input_min = ::tensorflow::ops::AsNodeOut(scope, input_min); |
1798 | if (!scope.ok()) return; |
1799 | auto _input_max = ::tensorflow::ops::AsNodeOut(scope, input_max); |
1800 | if (!scope.ok()) return; |
1801 | ::tensorflow::Node* ret; |
1802 | const auto unique_name = scope.GetUniqueNameForOp("QuantizeDownAndShrinkRange" ); |
1803 | auto builder = ::tensorflow::NodeBuilder(unique_name, "QuantizeDownAndShrinkRange" ) |
1804 | .Input(_input) |
1805 | .Input(_input_min) |
1806 | .Input(_input_max) |
1807 | .Attr("out_type" , out_type) |
1808 | ; |
1809 | scope.UpdateBuilder(&builder); |
1810 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1811 | if (!scope.ok()) return; |
1812 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1813 | this->operation = Operation(ret); |
1814 | ::tensorflow::NameRangeMap _outputs_range; |
1815 | ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range); |
1816 | if (!_status_.ok()) { |
1817 | scope.UpdateStatus(_status_); |
1818 | return; |
1819 | } |
1820 | |
1821 | this->output = Output(ret, _outputs_range["output" ].first); |
1822 | this->output_min = Output(ret, _outputs_range["output_min" ].first); |
1823 | this->output_max = Output(ret, _outputs_range["output_max" ].first); |
1824 | } |
1825 | |
1826 | QuantizedAdd::QuantizedAdd(const ::tensorflow::Scope& scope, |
1827 | ::tensorflow::Input x, ::tensorflow::Input y, |
1828 | ::tensorflow::Input min_x, ::tensorflow::Input |
1829 | max_x, ::tensorflow::Input min_y, |
1830 | ::tensorflow::Input max_y, const |
1831 | QuantizedAdd::Attrs& attrs) { |
1832 | if (!scope.ok()) return; |
1833 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1834 | if (!scope.ok()) return; |
1835 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1836 | if (!scope.ok()) return; |
1837 | auto _min_x = ::tensorflow::ops::AsNodeOut(scope, min_x); |
1838 | if (!scope.ok()) return; |
1839 | auto _max_x = ::tensorflow::ops::AsNodeOut(scope, max_x); |
1840 | if (!scope.ok()) return; |
1841 | auto _min_y = ::tensorflow::ops::AsNodeOut(scope, min_y); |
1842 | if (!scope.ok()) return; |
1843 | auto _max_y = ::tensorflow::ops::AsNodeOut(scope, max_y); |
1844 | if (!scope.ok()) return; |
1845 | ::tensorflow::Node* ret; |
1846 | const auto unique_name = scope.GetUniqueNameForOp("QuantizedAdd" ); |
1847 | auto builder = ::tensorflow::NodeBuilder(unique_name, "QuantizedAdd" ) |
1848 | .Input(_x) |
1849 | .Input(_y) |
1850 | .Input(_min_x) |
1851 | .Input(_max_x) |
1852 | .Input(_min_y) |
1853 | .Input(_max_y) |
1854 | .Attr("Toutput" , attrs.Toutput_) |
1855 | ; |
1856 | scope.UpdateBuilder(&builder); |
1857 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1858 | if (!scope.ok()) return; |
1859 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1860 | this->operation = Operation(ret); |
1861 | ::tensorflow::NameRangeMap _outputs_range; |
1862 | ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range); |
1863 | if (!_status_.ok()) { |
1864 | scope.UpdateStatus(_status_); |
1865 | return; |
1866 | } |
1867 | |
1868 | this->z = Output(ret, _outputs_range["z" ].first); |
1869 | this->min_z = Output(ret, _outputs_range["min_z" ].first); |
1870 | this->max_z = Output(ret, _outputs_range["max_z" ].first); |
1871 | } |
1872 | |
1873 | QuantizedAdd::QuantizedAdd(const ::tensorflow::Scope& scope, |
1874 | ::tensorflow::Input x, ::tensorflow::Input y, |
1875 | ::tensorflow::Input min_x, ::tensorflow::Input |
1876 | max_x, ::tensorflow::Input min_y, |
1877 | ::tensorflow::Input max_y) |
1878 | : QuantizedAdd(scope, x, y, min_x, max_x, min_y, max_y, QuantizedAdd::Attrs()) {} |
1879 | |
1880 | QuantizedMatMul::QuantizedMatMul(const ::tensorflow::Scope& scope, |
1881 | ::tensorflow::Input a, ::tensorflow::Input b, |
1882 | ::tensorflow::Input min_a, ::tensorflow::Input |
1883 | max_a, ::tensorflow::Input min_b, |
1884 | ::tensorflow::Input max_b, const |
1885 | QuantizedMatMul::Attrs& attrs) { |
1886 | if (!scope.ok()) return; |
1887 | auto _a = ::tensorflow::ops::AsNodeOut(scope, a); |
1888 | if (!scope.ok()) return; |
1889 | auto _b = ::tensorflow::ops::AsNodeOut(scope, b); |
1890 | if (!scope.ok()) return; |
1891 | auto _min_a = ::tensorflow::ops::AsNodeOut(scope, min_a); |
1892 | if (!scope.ok()) return; |
1893 | auto _max_a = ::tensorflow::ops::AsNodeOut(scope, max_a); |
1894 | if (!scope.ok()) return; |
1895 | auto _min_b = ::tensorflow::ops::AsNodeOut(scope, min_b); |
1896 | if (!scope.ok()) return; |
1897 | auto _max_b = ::tensorflow::ops::AsNodeOut(scope, max_b); |
1898 | if (!scope.ok()) return; |
1899 | ::tensorflow::Node* ret; |
1900 | const auto unique_name = scope.GetUniqueNameForOp("QuantizedMatMul" ); |
1901 | auto builder = ::tensorflow::NodeBuilder(unique_name, "QuantizedMatMul" ) |
1902 | .Input(_a) |
1903 | .Input(_b) |
1904 | .Input(_min_a) |
1905 | .Input(_max_a) |
1906 | .Input(_min_b) |
1907 | .Input(_max_b) |
1908 | .Attr("Toutput" , attrs.Toutput_) |
1909 | .Attr("transpose_a" , attrs.transpose_a_) |
1910 | .Attr("transpose_b" , attrs.transpose_b_) |
1911 | .Attr("Tactivation" , attrs.Tactivation_) |
1912 | ; |
1913 | scope.UpdateBuilder(&builder); |
1914 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1915 | if (!scope.ok()) return; |
1916 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1917 | this->operation = Operation(ret); |
1918 | ::tensorflow::NameRangeMap _outputs_range; |
1919 | ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range); |
1920 | if (!_status_.ok()) { |
1921 | scope.UpdateStatus(_status_); |
1922 | return; |
1923 | } |
1924 | |
1925 | this->out = Output(ret, _outputs_range["out" ].first); |
1926 | this->min_out = Output(ret, _outputs_range["min_out" ].first); |
1927 | this->max_out = Output(ret, _outputs_range["max_out" ].first); |
1928 | } |
1929 | |
1930 | QuantizedMatMul::QuantizedMatMul(const ::tensorflow::Scope& scope, |
1931 | ::tensorflow::Input a, ::tensorflow::Input b, |
1932 | ::tensorflow::Input min_a, ::tensorflow::Input |
1933 | max_a, ::tensorflow::Input min_b, |
1934 | ::tensorflow::Input max_b) |
1935 | : QuantizedMatMul(scope, a, b, min_a, max_a, min_b, max_b, QuantizedMatMul::Attrs()) {} |
1936 | |
1937 | QuantizedMul::QuantizedMul(const ::tensorflow::Scope& scope, |
1938 | ::tensorflow::Input x, ::tensorflow::Input y, |
1939 | ::tensorflow::Input min_x, ::tensorflow::Input |
1940 | max_x, ::tensorflow::Input min_y, |
1941 | ::tensorflow::Input max_y, const |
1942 | QuantizedMul::Attrs& attrs) { |
1943 | if (!scope.ok()) return; |
1944 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
1945 | if (!scope.ok()) return; |
1946 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
1947 | if (!scope.ok()) return; |
1948 | auto _min_x = ::tensorflow::ops::AsNodeOut(scope, min_x); |
1949 | if (!scope.ok()) return; |
1950 | auto _max_x = ::tensorflow::ops::AsNodeOut(scope, max_x); |
1951 | if (!scope.ok()) return; |
1952 | auto _min_y = ::tensorflow::ops::AsNodeOut(scope, min_y); |
1953 | if (!scope.ok()) return; |
1954 | auto _max_y = ::tensorflow::ops::AsNodeOut(scope, max_y); |
1955 | if (!scope.ok()) return; |
1956 | ::tensorflow::Node* ret; |
1957 | const auto unique_name = scope.GetUniqueNameForOp("QuantizedMul" ); |
1958 | auto builder = ::tensorflow::NodeBuilder(unique_name, "QuantizedMul" ) |
1959 | .Input(_x) |
1960 | .Input(_y) |
1961 | .Input(_min_x) |
1962 | .Input(_max_x) |
1963 | .Input(_min_y) |
1964 | .Input(_max_y) |
1965 | .Attr("Toutput" , attrs.Toutput_) |
1966 | ; |
1967 | scope.UpdateBuilder(&builder); |
1968 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1969 | if (!scope.ok()) return; |
1970 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1971 | this->operation = Operation(ret); |
1972 | ::tensorflow::NameRangeMap _outputs_range; |
1973 | ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range); |
1974 | if (!_status_.ok()) { |
1975 | scope.UpdateStatus(_status_); |
1976 | return; |
1977 | } |
1978 | |
1979 | this->z = Output(ret, _outputs_range["z" ].first); |
1980 | this->min_z = Output(ret, _outputs_range["min_z" ].first); |
1981 | this->max_z = Output(ret, _outputs_range["max_z" ].first); |
1982 | } |
1983 | |
1984 | QuantizedMul::QuantizedMul(const ::tensorflow::Scope& scope, |
1985 | ::tensorflow::Input x, ::tensorflow::Input y, |
1986 | ::tensorflow::Input min_x, ::tensorflow::Input |
1987 | max_x, ::tensorflow::Input min_y, |
1988 | ::tensorflow::Input max_y) |
1989 | : QuantizedMul(scope, x, y, min_x, max_x, min_y, max_y, QuantizedMul::Attrs()) {} |
1990 | |
1991 | RaggedBincount::RaggedBincount(const ::tensorflow::Scope& scope, |
1992 | ::tensorflow::Input splits, ::tensorflow::Input |
1993 | values, ::tensorflow::Input size, |
1994 | ::tensorflow::Input weights, const |
1995 | RaggedBincount::Attrs& attrs) { |
1996 | if (!scope.ok()) return; |
1997 | auto _splits = ::tensorflow::ops::AsNodeOut(scope, splits); |
1998 | if (!scope.ok()) return; |
1999 | auto _values = ::tensorflow::ops::AsNodeOut(scope, values); |
2000 | if (!scope.ok()) return; |
2001 | auto _size = ::tensorflow::ops::AsNodeOut(scope, size); |
2002 | if (!scope.ok()) return; |
2003 | auto _weights = ::tensorflow::ops::AsNodeOut(scope, weights); |
2004 | if (!scope.ok()) return; |
2005 | ::tensorflow::Node* ret; |
2006 | const auto unique_name = scope.GetUniqueNameForOp("RaggedBincount" ); |
2007 | auto builder = ::tensorflow::NodeBuilder(unique_name, "RaggedBincount" ) |
2008 | .Input(_splits) |
2009 | .Input(_values) |
2010 | .Input(_size) |
2011 | .Input(_weights) |
2012 | .Attr("binary_output" , attrs.binary_output_) |
2013 | ; |
2014 | scope.UpdateBuilder(&builder); |
2015 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2016 | if (!scope.ok()) return; |
2017 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2018 | this->operation = Operation(ret); |
2019 | this->output = Output(ret, 0); |
2020 | } |
2021 | |
2022 | RaggedBincount::RaggedBincount(const ::tensorflow::Scope& scope, |
2023 | ::tensorflow::Input splits, ::tensorflow::Input |
2024 | values, ::tensorflow::Input size, |
2025 | ::tensorflow::Input weights) |
2026 | : RaggedBincount(scope, splits, values, size, weights, RaggedBincount::Attrs()) {} |
2027 | |
2028 | Range::Range(const ::tensorflow::Scope& scope, ::tensorflow::Input start, |
2029 | ::tensorflow::Input limit, ::tensorflow::Input delta) { |
2030 | if (!scope.ok()) return; |
2031 | auto _start = ::tensorflow::ops::AsNodeOut(scope, start); |
2032 | if (!scope.ok()) return; |
2033 | auto _limit = ::tensorflow::ops::AsNodeOut(scope, limit); |
2034 | if (!scope.ok()) return; |
2035 | auto _delta = ::tensorflow::ops::AsNodeOut(scope, delta); |
2036 | if (!scope.ok()) return; |
2037 | ::tensorflow::Node* ret; |
2038 | const auto unique_name = scope.GetUniqueNameForOp("Range" ); |
2039 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Range" ) |
2040 | .Input(_start) |
2041 | .Input(_limit) |
2042 | .Input(_delta) |
2043 | ; |
2044 | scope.UpdateBuilder(&builder); |
2045 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2046 | if (!scope.ok()) return; |
2047 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2048 | this->operation = Operation(ret); |
2049 | this->output = Output(ret, 0); |
2050 | } |
2051 | |
2052 | Real::Real(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const |
2053 | Real::Attrs& attrs) { |
2054 | if (!scope.ok()) return; |
2055 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
2056 | if (!scope.ok()) return; |
2057 | ::tensorflow::Node* ret; |
2058 | const auto unique_name = scope.GetUniqueNameForOp("Real" ); |
2059 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Real" ) |
2060 | .Input(_input) |
2061 | .Attr("Tout" , attrs.Tout_) |
2062 | ; |
2063 | scope.UpdateBuilder(&builder); |
2064 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2065 | if (!scope.ok()) return; |
2066 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2067 | this->operation = Operation(ret); |
2068 | this->output = Output(ret, 0); |
2069 | } |
2070 | |
2071 | Real::Real(const ::tensorflow::Scope& scope, ::tensorflow::Input input) |
2072 | : Real(scope, input, Real::Attrs()) {} |
2073 | |
2074 | RealDiv::RealDiv(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
2075 | ::tensorflow::Input y) { |
2076 | if (!scope.ok()) return; |
2077 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2078 | if (!scope.ok()) return; |
2079 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
2080 | if (!scope.ok()) return; |
2081 | ::tensorflow::Node* ret; |
2082 | const auto unique_name = scope.GetUniqueNameForOp("RealDiv" ); |
2083 | auto builder = ::tensorflow::NodeBuilder(unique_name, "RealDiv" ) |
2084 | .Input(_x) |
2085 | .Input(_y) |
2086 | ; |
2087 | scope.UpdateBuilder(&builder); |
2088 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2089 | if (!scope.ok()) return; |
2090 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2091 | this->operation = Operation(ret); |
2092 | this->z = Output(ret, 0); |
2093 | } |
2094 | |
2095 | Reciprocal::Reciprocal(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
2096 | if (!scope.ok()) return; |
2097 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2098 | if (!scope.ok()) return; |
2099 | ::tensorflow::Node* ret; |
2100 | const auto unique_name = scope.GetUniqueNameForOp("Reciprocal" ); |
2101 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Reciprocal" ) |
2102 | .Input(_x) |
2103 | ; |
2104 | scope.UpdateBuilder(&builder); |
2105 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2106 | if (!scope.ok()) return; |
2107 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2108 | this->operation = Operation(ret); |
2109 | this->y = Output(ret, 0); |
2110 | } |
2111 | |
2112 | RequantizationRange::RequantizationRange(const ::tensorflow::Scope& scope, |
2113 | ::tensorflow::Input input, |
2114 | ::tensorflow::Input input_min, |
2115 | ::tensorflow::Input input_max) { |
2116 | if (!scope.ok()) return; |
2117 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
2118 | if (!scope.ok()) return; |
2119 | auto _input_min = ::tensorflow::ops::AsNodeOut(scope, input_min); |
2120 | if (!scope.ok()) return; |
2121 | auto _input_max = ::tensorflow::ops::AsNodeOut(scope, input_max); |
2122 | if (!scope.ok()) return; |
2123 | ::tensorflow::Node* ret; |
2124 | const auto unique_name = scope.GetUniqueNameForOp("RequantizationRange" ); |
2125 | auto builder = ::tensorflow::NodeBuilder(unique_name, "RequantizationRange" ) |
2126 | .Input(_input) |
2127 | .Input(_input_min) |
2128 | .Input(_input_max) |
2129 | ; |
2130 | scope.UpdateBuilder(&builder); |
2131 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2132 | if (!scope.ok()) return; |
2133 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2134 | this->operation = Operation(ret); |
2135 | ::tensorflow::NameRangeMap _outputs_range; |
2136 | ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range); |
2137 | if (!_status_.ok()) { |
2138 | scope.UpdateStatus(_status_); |
2139 | return; |
2140 | } |
2141 | |
2142 | this->output_min = Output(ret, _outputs_range["output_min" ].first); |
2143 | this->output_max = Output(ret, _outputs_range["output_max" ].first); |
2144 | } |
2145 | |
2146 | Requantize::Requantize(const ::tensorflow::Scope& scope, ::tensorflow::Input |
2147 | input, ::tensorflow::Input input_min, |
2148 | ::tensorflow::Input input_max, ::tensorflow::Input |
2149 | requested_output_min, ::tensorflow::Input |
2150 | requested_output_max, DataType out_type) { |
2151 | if (!scope.ok()) return; |
2152 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
2153 | if (!scope.ok()) return; |
2154 | auto _input_min = ::tensorflow::ops::AsNodeOut(scope, input_min); |
2155 | if (!scope.ok()) return; |
2156 | auto _input_max = ::tensorflow::ops::AsNodeOut(scope, input_max); |
2157 | if (!scope.ok()) return; |
2158 | auto _requested_output_min = ::tensorflow::ops::AsNodeOut(scope, requested_output_min); |
2159 | if (!scope.ok()) return; |
2160 | auto _requested_output_max = ::tensorflow::ops::AsNodeOut(scope, requested_output_max); |
2161 | if (!scope.ok()) return; |
2162 | ::tensorflow::Node* ret; |
2163 | const auto unique_name = scope.GetUniqueNameForOp("Requantize" ); |
2164 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Requantize" ) |
2165 | .Input(_input) |
2166 | .Input(_input_min) |
2167 | .Input(_input_max) |
2168 | .Input(_requested_output_min) |
2169 | .Input(_requested_output_max) |
2170 | .Attr("out_type" , out_type) |
2171 | ; |
2172 | scope.UpdateBuilder(&builder); |
2173 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2174 | if (!scope.ok()) return; |
2175 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2176 | this->operation = Operation(ret); |
2177 | ::tensorflow::NameRangeMap _outputs_range; |
2178 | ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range); |
2179 | if (!_status_.ok()) { |
2180 | scope.UpdateStatus(_status_); |
2181 | return; |
2182 | } |
2183 | |
2184 | this->output = Output(ret, _outputs_range["output" ].first); |
2185 | this->output_min = Output(ret, _outputs_range["output_min" ].first); |
2186 | this->output_max = Output(ret, _outputs_range["output_max" ].first); |
2187 | } |
2188 | |
2189 | Rint::Rint(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
2190 | if (!scope.ok()) return; |
2191 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2192 | if (!scope.ok()) return; |
2193 | ::tensorflow::Node* ret; |
2194 | const auto unique_name = scope.GetUniqueNameForOp("Rint" ); |
2195 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Rint" ) |
2196 | .Input(_x) |
2197 | ; |
2198 | scope.UpdateBuilder(&builder); |
2199 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2200 | if (!scope.ok()) return; |
2201 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2202 | this->operation = Operation(ret); |
2203 | this->y = Output(ret, 0); |
2204 | } |
2205 | |
2206 | Round::Round(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
2207 | if (!scope.ok()) return; |
2208 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2209 | if (!scope.ok()) return; |
2210 | ::tensorflow::Node* ret; |
2211 | const auto unique_name = scope.GetUniqueNameForOp("Round" ); |
2212 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Round" ) |
2213 | .Input(_x) |
2214 | ; |
2215 | scope.UpdateBuilder(&builder); |
2216 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2217 | if (!scope.ok()) return; |
2218 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2219 | this->operation = Operation(ret); |
2220 | this->y = Output(ret, 0); |
2221 | } |
2222 | |
2223 | Rsqrt::Rsqrt(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
2224 | if (!scope.ok()) return; |
2225 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2226 | if (!scope.ok()) return; |
2227 | ::tensorflow::Node* ret; |
2228 | const auto unique_name = scope.GetUniqueNameForOp("Rsqrt" ); |
2229 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Rsqrt" ) |
2230 | .Input(_x) |
2231 | ; |
2232 | scope.UpdateBuilder(&builder); |
2233 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2234 | if (!scope.ok()) return; |
2235 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2236 | this->operation = Operation(ret); |
2237 | this->y = Output(ret, 0); |
2238 | } |
2239 | |
2240 | SegmentMax::SegmentMax(const ::tensorflow::Scope& scope, ::tensorflow::Input |
2241 | data, ::tensorflow::Input segment_ids) { |
2242 | if (!scope.ok()) return; |
2243 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
2244 | if (!scope.ok()) return; |
2245 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2246 | if (!scope.ok()) return; |
2247 | ::tensorflow::Node* ret; |
2248 | const auto unique_name = scope.GetUniqueNameForOp("SegmentMax" ); |
2249 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SegmentMax" ) |
2250 | .Input(_data) |
2251 | .Input(_segment_ids) |
2252 | ; |
2253 | scope.UpdateBuilder(&builder); |
2254 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2255 | if (!scope.ok()) return; |
2256 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2257 | this->operation = Operation(ret); |
2258 | this->output = Output(ret, 0); |
2259 | } |
2260 | |
2261 | SegmentMean::SegmentMean(const ::tensorflow::Scope& scope, ::tensorflow::Input |
2262 | data, ::tensorflow::Input segment_ids) { |
2263 | if (!scope.ok()) return; |
2264 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
2265 | if (!scope.ok()) return; |
2266 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2267 | if (!scope.ok()) return; |
2268 | ::tensorflow::Node* ret; |
2269 | const auto unique_name = scope.GetUniqueNameForOp("SegmentMean" ); |
2270 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SegmentMean" ) |
2271 | .Input(_data) |
2272 | .Input(_segment_ids) |
2273 | ; |
2274 | scope.UpdateBuilder(&builder); |
2275 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2276 | if (!scope.ok()) return; |
2277 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2278 | this->operation = Operation(ret); |
2279 | this->output = Output(ret, 0); |
2280 | } |
2281 | |
2282 | SegmentMin::SegmentMin(const ::tensorflow::Scope& scope, ::tensorflow::Input |
2283 | data, ::tensorflow::Input segment_ids) { |
2284 | if (!scope.ok()) return; |
2285 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
2286 | if (!scope.ok()) return; |
2287 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2288 | if (!scope.ok()) return; |
2289 | ::tensorflow::Node* ret; |
2290 | const auto unique_name = scope.GetUniqueNameForOp("SegmentMin" ); |
2291 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SegmentMin" ) |
2292 | .Input(_data) |
2293 | .Input(_segment_ids) |
2294 | ; |
2295 | scope.UpdateBuilder(&builder); |
2296 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2297 | if (!scope.ok()) return; |
2298 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2299 | this->operation = Operation(ret); |
2300 | this->output = Output(ret, 0); |
2301 | } |
2302 | |
2303 | SegmentProd::SegmentProd(const ::tensorflow::Scope& scope, ::tensorflow::Input |
2304 | data, ::tensorflow::Input segment_ids) { |
2305 | if (!scope.ok()) return; |
2306 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
2307 | if (!scope.ok()) return; |
2308 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2309 | if (!scope.ok()) return; |
2310 | ::tensorflow::Node* ret; |
2311 | const auto unique_name = scope.GetUniqueNameForOp("SegmentProd" ); |
2312 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SegmentProd" ) |
2313 | .Input(_data) |
2314 | .Input(_segment_ids) |
2315 | ; |
2316 | scope.UpdateBuilder(&builder); |
2317 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2318 | if (!scope.ok()) return; |
2319 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2320 | this->operation = Operation(ret); |
2321 | this->output = Output(ret, 0); |
2322 | } |
2323 | |
2324 | SegmentSum::SegmentSum(const ::tensorflow::Scope& scope, ::tensorflow::Input |
2325 | data, ::tensorflow::Input segment_ids) { |
2326 | if (!scope.ok()) return; |
2327 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
2328 | if (!scope.ok()) return; |
2329 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2330 | if (!scope.ok()) return; |
2331 | ::tensorflow::Node* ret; |
2332 | const auto unique_name = scope.GetUniqueNameForOp("SegmentSum" ); |
2333 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SegmentSum" ) |
2334 | .Input(_data) |
2335 | .Input(_segment_ids) |
2336 | ; |
2337 | scope.UpdateBuilder(&builder); |
2338 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2339 | if (!scope.ok()) return; |
2340 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2341 | this->operation = Operation(ret); |
2342 | this->output = Output(ret, 0); |
2343 | } |
2344 | |
2345 | Where3::Where3(const ::tensorflow::Scope& scope, ::tensorflow::Input condition, |
2346 | ::tensorflow::Input x, ::tensorflow::Input y) { |
2347 | if (!scope.ok()) return; |
2348 | auto _condition = ::tensorflow::ops::AsNodeOut(scope, condition); |
2349 | if (!scope.ok()) return; |
2350 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2351 | if (!scope.ok()) return; |
2352 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
2353 | if (!scope.ok()) return; |
2354 | ::tensorflow::Node* ret; |
2355 | const auto unique_name = scope.GetUniqueNameForOp("Where3" ); |
2356 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Select" ) |
2357 | .Input(_condition) |
2358 | .Input(_x) |
2359 | .Input(_y) |
2360 | ; |
2361 | scope.UpdateBuilder(&builder); |
2362 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2363 | if (!scope.ok()) return; |
2364 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2365 | this->operation = Operation(ret); |
2366 | this->output = Output(ret, 0); |
2367 | } |
2368 | |
2369 | SelectV2::SelectV2(const ::tensorflow::Scope& scope, ::tensorflow::Input |
2370 | condition, ::tensorflow::Input t, ::tensorflow::Input e) { |
2371 | if (!scope.ok()) return; |
2372 | auto _condition = ::tensorflow::ops::AsNodeOut(scope, condition); |
2373 | if (!scope.ok()) return; |
2374 | auto _t = ::tensorflow::ops::AsNodeOut(scope, t); |
2375 | if (!scope.ok()) return; |
2376 | auto _e = ::tensorflow::ops::AsNodeOut(scope, e); |
2377 | if (!scope.ok()) return; |
2378 | ::tensorflow::Node* ret; |
2379 | const auto unique_name = scope.GetUniqueNameForOp("SelectV2" ); |
2380 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SelectV2" ) |
2381 | .Input(_condition) |
2382 | .Input(_t) |
2383 | .Input(_e) |
2384 | ; |
2385 | scope.UpdateBuilder(&builder); |
2386 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2387 | if (!scope.ok()) return; |
2388 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2389 | this->operation = Operation(ret); |
2390 | this->output = Output(ret, 0); |
2391 | } |
2392 | |
2393 | Sigmoid::Sigmoid(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
2394 | if (!scope.ok()) return; |
2395 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2396 | if (!scope.ok()) return; |
2397 | ::tensorflow::Node* ret; |
2398 | const auto unique_name = scope.GetUniqueNameForOp("Sigmoid" ); |
2399 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Sigmoid" ) |
2400 | .Input(_x) |
2401 | ; |
2402 | scope.UpdateBuilder(&builder); |
2403 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2404 | if (!scope.ok()) return; |
2405 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2406 | this->operation = Operation(ret); |
2407 | this->y = Output(ret, 0); |
2408 | } |
2409 | |
2410 | Sign::Sign(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
2411 | if (!scope.ok()) return; |
2412 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2413 | if (!scope.ok()) return; |
2414 | ::tensorflow::Node* ret; |
2415 | const auto unique_name = scope.GetUniqueNameForOp("Sign" ); |
2416 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Sign" ) |
2417 | .Input(_x) |
2418 | ; |
2419 | scope.UpdateBuilder(&builder); |
2420 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2421 | if (!scope.ok()) return; |
2422 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2423 | this->operation = Operation(ret); |
2424 | this->y = Output(ret, 0); |
2425 | } |
2426 | |
2427 | Sin::Sin(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
2428 | if (!scope.ok()) return; |
2429 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2430 | if (!scope.ok()) return; |
2431 | ::tensorflow::Node* ret; |
2432 | const auto unique_name = scope.GetUniqueNameForOp("Sin" ); |
2433 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Sin" ) |
2434 | .Input(_x) |
2435 | ; |
2436 | scope.UpdateBuilder(&builder); |
2437 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2438 | if (!scope.ok()) return; |
2439 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2440 | this->operation = Operation(ret); |
2441 | this->y = Output(ret, 0); |
2442 | } |
2443 | |
2444 | Sinh::Sinh(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
2445 | if (!scope.ok()) return; |
2446 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2447 | if (!scope.ok()) return; |
2448 | ::tensorflow::Node* ret; |
2449 | const auto unique_name = scope.GetUniqueNameForOp("Sinh" ); |
2450 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Sinh" ) |
2451 | .Input(_x) |
2452 | ; |
2453 | scope.UpdateBuilder(&builder); |
2454 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2455 | if (!scope.ok()) return; |
2456 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2457 | this->operation = Operation(ret); |
2458 | this->y = Output(ret, 0); |
2459 | } |
2460 | |
2461 | SparseBincount::SparseBincount(const ::tensorflow::Scope& scope, |
2462 | ::tensorflow::Input indices, ::tensorflow::Input |
2463 | values, ::tensorflow::Input dense_shape, |
2464 | ::tensorflow::Input size, ::tensorflow::Input |
2465 | weights, const SparseBincount::Attrs& attrs) { |
2466 | if (!scope.ok()) return; |
2467 | auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices); |
2468 | if (!scope.ok()) return; |
2469 | auto _values = ::tensorflow::ops::AsNodeOut(scope, values); |
2470 | if (!scope.ok()) return; |
2471 | auto _dense_shape = ::tensorflow::ops::AsNodeOut(scope, dense_shape); |
2472 | if (!scope.ok()) return; |
2473 | auto _size = ::tensorflow::ops::AsNodeOut(scope, size); |
2474 | if (!scope.ok()) return; |
2475 | auto _weights = ::tensorflow::ops::AsNodeOut(scope, weights); |
2476 | if (!scope.ok()) return; |
2477 | ::tensorflow::Node* ret; |
2478 | const auto unique_name = scope.GetUniqueNameForOp("SparseBincount" ); |
2479 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseBincount" ) |
2480 | .Input(_indices) |
2481 | .Input(_values) |
2482 | .Input(_dense_shape) |
2483 | .Input(_size) |
2484 | .Input(_weights) |
2485 | .Attr("binary_output" , attrs.binary_output_) |
2486 | ; |
2487 | scope.UpdateBuilder(&builder); |
2488 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2489 | if (!scope.ok()) return; |
2490 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2491 | this->operation = Operation(ret); |
2492 | this->output = Output(ret, 0); |
2493 | } |
2494 | |
2495 | SparseBincount::SparseBincount(const ::tensorflow::Scope& scope, |
2496 | ::tensorflow::Input indices, ::tensorflow::Input |
2497 | values, ::tensorflow::Input dense_shape, |
2498 | ::tensorflow::Input size, ::tensorflow::Input |
2499 | weights) |
2500 | : SparseBincount(scope, indices, values, dense_shape, size, weights, SparseBincount::Attrs()) {} |
2501 | |
2502 | SparseMatMul::SparseMatMul(const ::tensorflow::Scope& scope, |
2503 | ::tensorflow::Input a, ::tensorflow::Input b, const |
2504 | SparseMatMul::Attrs& attrs) { |
2505 | if (!scope.ok()) return; |
2506 | auto _a = ::tensorflow::ops::AsNodeOut(scope, a); |
2507 | if (!scope.ok()) return; |
2508 | auto _b = ::tensorflow::ops::AsNodeOut(scope, b); |
2509 | if (!scope.ok()) return; |
2510 | ::tensorflow::Node* ret; |
2511 | const auto unique_name = scope.GetUniqueNameForOp("SparseMatMul" ); |
2512 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseMatMul" ) |
2513 | .Input(_a) |
2514 | .Input(_b) |
2515 | .Attr("transpose_a" , attrs.transpose_a_) |
2516 | .Attr("transpose_b" , attrs.transpose_b_) |
2517 | .Attr("a_is_sparse" , attrs.a_is_sparse_) |
2518 | .Attr("b_is_sparse" , attrs.b_is_sparse_) |
2519 | ; |
2520 | scope.UpdateBuilder(&builder); |
2521 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2522 | if (!scope.ok()) return; |
2523 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2524 | this->operation = Operation(ret); |
2525 | this->product = Output(ret, 0); |
2526 | } |
2527 | |
2528 | SparseMatMul::SparseMatMul(const ::tensorflow::Scope& scope, |
2529 | ::tensorflow::Input a, ::tensorflow::Input b) |
2530 | : SparseMatMul(scope, a, b, SparseMatMul::Attrs()) {} |
2531 | |
2532 | SparseSegmentMean::SparseSegmentMean(const ::tensorflow::Scope& scope, |
2533 | ::tensorflow::Input data, |
2534 | ::tensorflow::Input indices, |
2535 | ::tensorflow::Input segment_ids) { |
2536 | if (!scope.ok()) return; |
2537 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
2538 | if (!scope.ok()) return; |
2539 | auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices); |
2540 | if (!scope.ok()) return; |
2541 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2542 | if (!scope.ok()) return; |
2543 | ::tensorflow::Node* ret; |
2544 | const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentMean" ); |
2545 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentMean" ) |
2546 | .Input(_data) |
2547 | .Input(_indices) |
2548 | .Input(_segment_ids) |
2549 | ; |
2550 | scope.UpdateBuilder(&builder); |
2551 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2552 | if (!scope.ok()) return; |
2553 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2554 | this->operation = Operation(ret); |
2555 | this->output = Output(ret, 0); |
2556 | } |
2557 | |
2558 | SparseSegmentMeanGrad::SparseSegmentMeanGrad(const ::tensorflow::Scope& scope, |
2559 | ::tensorflow::Input grad, |
2560 | ::tensorflow::Input indices, |
2561 | ::tensorflow::Input segment_ids, |
2562 | ::tensorflow::Input output_dim0) { |
2563 | if (!scope.ok()) return; |
2564 | auto _grad = ::tensorflow::ops::AsNodeOut(scope, grad); |
2565 | if (!scope.ok()) return; |
2566 | auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices); |
2567 | if (!scope.ok()) return; |
2568 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2569 | if (!scope.ok()) return; |
2570 | auto _output_dim0 = ::tensorflow::ops::AsNodeOut(scope, output_dim0); |
2571 | if (!scope.ok()) return; |
2572 | ::tensorflow::Node* ret; |
2573 | const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentMeanGrad" ); |
2574 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentMeanGrad" ) |
2575 | .Input(_grad) |
2576 | .Input(_indices) |
2577 | .Input(_segment_ids) |
2578 | .Input(_output_dim0) |
2579 | ; |
2580 | scope.UpdateBuilder(&builder); |
2581 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2582 | if (!scope.ok()) return; |
2583 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2584 | this->operation = Operation(ret); |
2585 | this->output = Output(ret, 0); |
2586 | } |
2587 | |
2588 | SparseSegmentMeanWithNumSegments::SparseSegmentMeanWithNumSegments(const |
2589 | ::tensorflow::Scope& |
2590 | scope, |
2591 | ::tensorflow::Input |
2592 | data, |
2593 | ::tensorflow::Input |
2594 | indices, |
2595 | ::tensorflow::Input |
2596 | segment_ids, |
2597 | ::tensorflow::Input |
2598 | num_segments) { |
2599 | if (!scope.ok()) return; |
2600 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
2601 | if (!scope.ok()) return; |
2602 | auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices); |
2603 | if (!scope.ok()) return; |
2604 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2605 | if (!scope.ok()) return; |
2606 | auto _num_segments = ::tensorflow::ops::AsNodeOut(scope, num_segments); |
2607 | if (!scope.ok()) return; |
2608 | ::tensorflow::Node* ret; |
2609 | const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentMeanWithNumSegments" ); |
2610 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentMeanWithNumSegments" ) |
2611 | .Input(_data) |
2612 | .Input(_indices) |
2613 | .Input(_segment_ids) |
2614 | .Input(_num_segments) |
2615 | ; |
2616 | scope.UpdateBuilder(&builder); |
2617 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2618 | if (!scope.ok()) return; |
2619 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2620 | this->operation = Operation(ret); |
2621 | this->output = Output(ret, 0); |
2622 | } |
2623 | |
2624 | SparseSegmentSqrtN::SparseSegmentSqrtN(const ::tensorflow::Scope& scope, |
2625 | ::tensorflow::Input data, |
2626 | ::tensorflow::Input indices, |
2627 | ::tensorflow::Input segment_ids) { |
2628 | if (!scope.ok()) return; |
2629 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
2630 | if (!scope.ok()) return; |
2631 | auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices); |
2632 | if (!scope.ok()) return; |
2633 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2634 | if (!scope.ok()) return; |
2635 | ::tensorflow::Node* ret; |
2636 | const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentSqrtN" ); |
2637 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentSqrtN" ) |
2638 | .Input(_data) |
2639 | .Input(_indices) |
2640 | .Input(_segment_ids) |
2641 | ; |
2642 | scope.UpdateBuilder(&builder); |
2643 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2644 | if (!scope.ok()) return; |
2645 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2646 | this->operation = Operation(ret); |
2647 | this->output = Output(ret, 0); |
2648 | } |
2649 | |
2650 | SparseSegmentSqrtNGrad::SparseSegmentSqrtNGrad(const ::tensorflow::Scope& |
2651 | scope, ::tensorflow::Input grad, |
2652 | ::tensorflow::Input indices, |
2653 | ::tensorflow::Input segment_ids, |
2654 | ::tensorflow::Input output_dim0) { |
2655 | if (!scope.ok()) return; |
2656 | auto _grad = ::tensorflow::ops::AsNodeOut(scope, grad); |
2657 | if (!scope.ok()) return; |
2658 | auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices); |
2659 | if (!scope.ok()) return; |
2660 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2661 | if (!scope.ok()) return; |
2662 | auto _output_dim0 = ::tensorflow::ops::AsNodeOut(scope, output_dim0); |
2663 | if (!scope.ok()) return; |
2664 | ::tensorflow::Node* ret; |
2665 | const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentSqrtNGrad" ); |
2666 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentSqrtNGrad" ) |
2667 | .Input(_grad) |
2668 | .Input(_indices) |
2669 | .Input(_segment_ids) |
2670 | .Input(_output_dim0) |
2671 | ; |
2672 | scope.UpdateBuilder(&builder); |
2673 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2674 | if (!scope.ok()) return; |
2675 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2676 | this->operation = Operation(ret); |
2677 | this->output = Output(ret, 0); |
2678 | } |
2679 | |
2680 | SparseSegmentSqrtNWithNumSegments::SparseSegmentSqrtNWithNumSegments(const |
2681 | ::tensorflow::Scope& |
2682 | scope, |
2683 | ::tensorflow::Input |
2684 | data, |
2685 | ::tensorflow::Input |
2686 | indices, |
2687 | ::tensorflow::Input |
2688 | segment_ids, |
2689 | ::tensorflow::Input |
2690 | num_segments) { |
2691 | if (!scope.ok()) return; |
2692 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
2693 | if (!scope.ok()) return; |
2694 | auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices); |
2695 | if (!scope.ok()) return; |
2696 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2697 | if (!scope.ok()) return; |
2698 | auto _num_segments = ::tensorflow::ops::AsNodeOut(scope, num_segments); |
2699 | if (!scope.ok()) return; |
2700 | ::tensorflow::Node* ret; |
2701 | const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentSqrtNWithNumSegments" ); |
2702 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentSqrtNWithNumSegments" ) |
2703 | .Input(_data) |
2704 | .Input(_indices) |
2705 | .Input(_segment_ids) |
2706 | .Input(_num_segments) |
2707 | ; |
2708 | scope.UpdateBuilder(&builder); |
2709 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2710 | if (!scope.ok()) return; |
2711 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2712 | this->operation = Operation(ret); |
2713 | this->output = Output(ret, 0); |
2714 | } |
2715 | |
2716 | SparseSegmentSum::SparseSegmentSum(const ::tensorflow::Scope& scope, |
2717 | ::tensorflow::Input data, |
2718 | ::tensorflow::Input indices, |
2719 | ::tensorflow::Input segment_ids) { |
2720 | if (!scope.ok()) return; |
2721 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
2722 | if (!scope.ok()) return; |
2723 | auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices); |
2724 | if (!scope.ok()) return; |
2725 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2726 | if (!scope.ok()) return; |
2727 | ::tensorflow::Node* ret; |
2728 | const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentSum" ); |
2729 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentSum" ) |
2730 | .Input(_data) |
2731 | .Input(_indices) |
2732 | .Input(_segment_ids) |
2733 | ; |
2734 | scope.UpdateBuilder(&builder); |
2735 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2736 | if (!scope.ok()) return; |
2737 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2738 | this->operation = Operation(ret); |
2739 | this->output = Output(ret, 0); |
2740 | } |
2741 | |
2742 | SparseSegmentSumGrad::SparseSegmentSumGrad(const ::tensorflow::Scope& scope, |
2743 | ::tensorflow::Input grad, |
2744 | ::tensorflow::Input indices, |
2745 | ::tensorflow::Input segment_ids, |
2746 | ::tensorflow::Input output_dim0) { |
2747 | if (!scope.ok()) return; |
2748 | auto _grad = ::tensorflow::ops::AsNodeOut(scope, grad); |
2749 | if (!scope.ok()) return; |
2750 | auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices); |
2751 | if (!scope.ok()) return; |
2752 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2753 | if (!scope.ok()) return; |
2754 | auto _output_dim0 = ::tensorflow::ops::AsNodeOut(scope, output_dim0); |
2755 | if (!scope.ok()) return; |
2756 | ::tensorflow::Node* ret; |
2757 | const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentSumGrad" ); |
2758 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentSumGrad" ) |
2759 | .Input(_grad) |
2760 | .Input(_indices) |
2761 | .Input(_segment_ids) |
2762 | .Input(_output_dim0) |
2763 | ; |
2764 | scope.UpdateBuilder(&builder); |
2765 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2766 | if (!scope.ok()) return; |
2767 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2768 | this->operation = Operation(ret); |
2769 | this->output = Output(ret, 0); |
2770 | } |
2771 | |
2772 | SparseSegmentSumWithNumSegments::SparseSegmentSumWithNumSegments(const |
2773 | ::tensorflow::Scope& |
2774 | scope, |
2775 | ::tensorflow::Input |
2776 | data, |
2777 | ::tensorflow::Input |
2778 | indices, |
2779 | ::tensorflow::Input |
2780 | segment_ids, |
2781 | ::tensorflow::Input |
2782 | num_segments) { |
2783 | if (!scope.ok()) return; |
2784 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
2785 | if (!scope.ok()) return; |
2786 | auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices); |
2787 | if (!scope.ok()) return; |
2788 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2789 | if (!scope.ok()) return; |
2790 | auto _num_segments = ::tensorflow::ops::AsNodeOut(scope, num_segments); |
2791 | if (!scope.ok()) return; |
2792 | ::tensorflow::Node* ret; |
2793 | const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentSumWithNumSegments" ); |
2794 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentSumWithNumSegments" ) |
2795 | .Input(_data) |
2796 | .Input(_indices) |
2797 | .Input(_segment_ids) |
2798 | .Input(_num_segments) |
2799 | ; |
2800 | scope.UpdateBuilder(&builder); |
2801 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2802 | if (!scope.ok()) return; |
2803 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2804 | this->operation = Operation(ret); |
2805 | this->output = Output(ret, 0); |
2806 | } |
2807 | |
2808 | Sqrt::Sqrt(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
2809 | if (!scope.ok()) return; |
2810 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2811 | if (!scope.ok()) return; |
2812 | ::tensorflow::Node* ret; |
2813 | const auto unique_name = scope.GetUniqueNameForOp("Sqrt" ); |
2814 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Sqrt" ) |
2815 | .Input(_x) |
2816 | ; |
2817 | scope.UpdateBuilder(&builder); |
2818 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2819 | if (!scope.ok()) return; |
2820 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2821 | this->operation = Operation(ret); |
2822 | this->y = Output(ret, 0); |
2823 | } |
2824 | |
2825 | Square::Square(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
2826 | if (!scope.ok()) return; |
2827 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2828 | if (!scope.ok()) return; |
2829 | ::tensorflow::Node* ret; |
2830 | const auto unique_name = scope.GetUniqueNameForOp("Square" ); |
2831 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Square" ) |
2832 | .Input(_x) |
2833 | ; |
2834 | scope.UpdateBuilder(&builder); |
2835 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2836 | if (!scope.ok()) return; |
2837 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2838 | this->operation = Operation(ret); |
2839 | this->y = Output(ret, 0); |
2840 | } |
2841 | |
2842 | SquaredDifference::SquaredDifference(const ::tensorflow::Scope& scope, |
2843 | ::tensorflow::Input x, ::tensorflow::Input |
2844 | y) { |
2845 | if (!scope.ok()) return; |
2846 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2847 | if (!scope.ok()) return; |
2848 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
2849 | if (!scope.ok()) return; |
2850 | ::tensorflow::Node* ret; |
2851 | const auto unique_name = scope.GetUniqueNameForOp("SquaredDifference" ); |
2852 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SquaredDifference" ) |
2853 | .Input(_x) |
2854 | .Input(_y) |
2855 | ; |
2856 | scope.UpdateBuilder(&builder); |
2857 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2858 | if (!scope.ok()) return; |
2859 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2860 | this->operation = Operation(ret); |
2861 | this->z = Output(ret, 0); |
2862 | } |
2863 | |
2864 | Subtract::Subtract(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
2865 | ::tensorflow::Input y) { |
2866 | if (!scope.ok()) return; |
2867 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2868 | if (!scope.ok()) return; |
2869 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
2870 | if (!scope.ok()) return; |
2871 | ::tensorflow::Node* ret; |
2872 | const auto unique_name = scope.GetUniqueNameForOp("Subtract" ); |
2873 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Sub" ) |
2874 | .Input(_x) |
2875 | .Input(_y) |
2876 | ; |
2877 | scope.UpdateBuilder(&builder); |
2878 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2879 | if (!scope.ok()) return; |
2880 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2881 | this->operation = Operation(ret); |
2882 | this->z = Output(ret, 0); |
2883 | } |
2884 | |
2885 | Sum::Sum(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
2886 | ::tensorflow::Input axis, const Sum::Attrs& attrs) { |
2887 | if (!scope.ok()) return; |
2888 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
2889 | if (!scope.ok()) return; |
2890 | auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis); |
2891 | if (!scope.ok()) return; |
2892 | ::tensorflow::Node* ret; |
2893 | const auto unique_name = scope.GetUniqueNameForOp("Sum" ); |
2894 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Sum" ) |
2895 | .Input(_input) |
2896 | .Input(_axis) |
2897 | .Attr("keep_dims" , attrs.keep_dims_) |
2898 | ; |
2899 | scope.UpdateBuilder(&builder); |
2900 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2901 | if (!scope.ok()) return; |
2902 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2903 | this->operation = Operation(ret); |
2904 | this->output = Output(ret, 0); |
2905 | } |
2906 | |
2907 | Sum::Sum(const ::tensorflow::Scope& scope, ::tensorflow::Input input, |
2908 | ::tensorflow::Input axis) |
2909 | : Sum(scope, input, axis, Sum::Attrs()) {} |
2910 | |
2911 | Tan::Tan(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
2912 | if (!scope.ok()) return; |
2913 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2914 | if (!scope.ok()) return; |
2915 | ::tensorflow::Node* ret; |
2916 | const auto unique_name = scope.GetUniqueNameForOp("Tan" ); |
2917 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Tan" ) |
2918 | .Input(_x) |
2919 | ; |
2920 | scope.UpdateBuilder(&builder); |
2921 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2922 | if (!scope.ok()) return; |
2923 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2924 | this->operation = Operation(ret); |
2925 | this->y = Output(ret, 0); |
2926 | } |
2927 | |
2928 | Tanh::Tanh(const ::tensorflow::Scope& scope, ::tensorflow::Input x) { |
2929 | if (!scope.ok()) return; |
2930 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2931 | if (!scope.ok()) return; |
2932 | ::tensorflow::Node* ret; |
2933 | const auto unique_name = scope.GetUniqueNameForOp("Tanh" ); |
2934 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Tanh" ) |
2935 | .Input(_x) |
2936 | ; |
2937 | scope.UpdateBuilder(&builder); |
2938 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2939 | if (!scope.ok()) return; |
2940 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2941 | this->operation = Operation(ret); |
2942 | this->y = Output(ret, 0); |
2943 | } |
2944 | |
2945 | TruncateDiv::TruncateDiv(const ::tensorflow::Scope& scope, ::tensorflow::Input |
2946 | x, ::tensorflow::Input y) { |
2947 | if (!scope.ok()) return; |
2948 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2949 | if (!scope.ok()) return; |
2950 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
2951 | if (!scope.ok()) return; |
2952 | ::tensorflow::Node* ret; |
2953 | const auto unique_name = scope.GetUniqueNameForOp("TruncateDiv" ); |
2954 | auto builder = ::tensorflow::NodeBuilder(unique_name, "TruncateDiv" ) |
2955 | .Input(_x) |
2956 | .Input(_y) |
2957 | ; |
2958 | scope.UpdateBuilder(&builder); |
2959 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2960 | if (!scope.ok()) return; |
2961 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2962 | this->operation = Operation(ret); |
2963 | this->z = Output(ret, 0); |
2964 | } |
2965 | |
2966 | TruncateMod::TruncateMod(const ::tensorflow::Scope& scope, ::tensorflow::Input |
2967 | x, ::tensorflow::Input y) { |
2968 | if (!scope.ok()) return; |
2969 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
2970 | if (!scope.ok()) return; |
2971 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
2972 | if (!scope.ok()) return; |
2973 | ::tensorflow::Node* ret; |
2974 | const auto unique_name = scope.GetUniqueNameForOp("TruncateMod" ); |
2975 | auto builder = ::tensorflow::NodeBuilder(unique_name, "TruncateMod" ) |
2976 | .Input(_x) |
2977 | .Input(_y) |
2978 | ; |
2979 | scope.UpdateBuilder(&builder); |
2980 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2981 | if (!scope.ok()) return; |
2982 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2983 | this->operation = Operation(ret); |
2984 | this->z = Output(ret, 0); |
2985 | } |
2986 | |
2987 | UnsortedSegmentMax::UnsortedSegmentMax(const ::tensorflow::Scope& scope, |
2988 | ::tensorflow::Input data, |
2989 | ::tensorflow::Input segment_ids, |
2990 | ::tensorflow::Input num_segments) { |
2991 | if (!scope.ok()) return; |
2992 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
2993 | if (!scope.ok()) return; |
2994 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
2995 | if (!scope.ok()) return; |
2996 | auto _num_segments = ::tensorflow::ops::AsNodeOut(scope, num_segments); |
2997 | if (!scope.ok()) return; |
2998 | ::tensorflow::Node* ret; |
2999 | const auto unique_name = scope.GetUniqueNameForOp("UnsortedSegmentMax" ); |
3000 | auto builder = ::tensorflow::NodeBuilder(unique_name, "UnsortedSegmentMax" ) |
3001 | .Input(_data) |
3002 | .Input(_segment_ids) |
3003 | .Input(_num_segments) |
3004 | ; |
3005 | scope.UpdateBuilder(&builder); |
3006 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3007 | if (!scope.ok()) return; |
3008 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3009 | this->operation = Operation(ret); |
3010 | this->output = Output(ret, 0); |
3011 | } |
3012 | |
3013 | UnsortedSegmentMin::UnsortedSegmentMin(const ::tensorflow::Scope& scope, |
3014 | ::tensorflow::Input data, |
3015 | ::tensorflow::Input segment_ids, |
3016 | ::tensorflow::Input num_segments) { |
3017 | if (!scope.ok()) return; |
3018 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
3019 | if (!scope.ok()) return; |
3020 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
3021 | if (!scope.ok()) return; |
3022 | auto _num_segments = ::tensorflow::ops::AsNodeOut(scope, num_segments); |
3023 | if (!scope.ok()) return; |
3024 | ::tensorflow::Node* ret; |
3025 | const auto unique_name = scope.GetUniqueNameForOp("UnsortedSegmentMin" ); |
3026 | auto builder = ::tensorflow::NodeBuilder(unique_name, "UnsortedSegmentMin" ) |
3027 | .Input(_data) |
3028 | .Input(_segment_ids) |
3029 | .Input(_num_segments) |
3030 | ; |
3031 | scope.UpdateBuilder(&builder); |
3032 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3033 | if (!scope.ok()) return; |
3034 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3035 | this->operation = Operation(ret); |
3036 | this->output = Output(ret, 0); |
3037 | } |
3038 | |
3039 | UnsortedSegmentProd::UnsortedSegmentProd(const ::tensorflow::Scope& scope, |
3040 | ::tensorflow::Input data, |
3041 | ::tensorflow::Input segment_ids, |
3042 | ::tensorflow::Input num_segments) { |
3043 | if (!scope.ok()) return; |
3044 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
3045 | if (!scope.ok()) return; |
3046 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
3047 | if (!scope.ok()) return; |
3048 | auto _num_segments = ::tensorflow::ops::AsNodeOut(scope, num_segments); |
3049 | if (!scope.ok()) return; |
3050 | ::tensorflow::Node* ret; |
3051 | const auto unique_name = scope.GetUniqueNameForOp("UnsortedSegmentProd" ); |
3052 | auto builder = ::tensorflow::NodeBuilder(unique_name, "UnsortedSegmentProd" ) |
3053 | .Input(_data) |
3054 | .Input(_segment_ids) |
3055 | .Input(_num_segments) |
3056 | ; |
3057 | scope.UpdateBuilder(&builder); |
3058 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3059 | if (!scope.ok()) return; |
3060 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3061 | this->operation = Operation(ret); |
3062 | this->output = Output(ret, 0); |
3063 | } |
3064 | |
3065 | UnsortedSegmentSum::UnsortedSegmentSum(const ::tensorflow::Scope& scope, |
3066 | ::tensorflow::Input data, |
3067 | ::tensorflow::Input segment_ids, |
3068 | ::tensorflow::Input num_segments) { |
3069 | if (!scope.ok()) return; |
3070 | auto _data = ::tensorflow::ops::AsNodeOut(scope, data); |
3071 | if (!scope.ok()) return; |
3072 | auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids); |
3073 | if (!scope.ok()) return; |
3074 | auto _num_segments = ::tensorflow::ops::AsNodeOut(scope, num_segments); |
3075 | if (!scope.ok()) return; |
3076 | ::tensorflow::Node* ret; |
3077 | const auto unique_name = scope.GetUniqueNameForOp("UnsortedSegmentSum" ); |
3078 | auto builder = ::tensorflow::NodeBuilder(unique_name, "UnsortedSegmentSum" ) |
3079 | .Input(_data) |
3080 | .Input(_segment_ids) |
3081 | .Input(_num_segments) |
3082 | ; |
3083 | scope.UpdateBuilder(&builder); |
3084 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3085 | if (!scope.ok()) return; |
3086 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3087 | this->operation = Operation(ret); |
3088 | this->output = Output(ret, 0); |
3089 | } |
3090 | |
3091 | Xdivy::Xdivy(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
3092 | ::tensorflow::Input y) { |
3093 | if (!scope.ok()) return; |
3094 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
3095 | if (!scope.ok()) return; |
3096 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
3097 | if (!scope.ok()) return; |
3098 | ::tensorflow::Node* ret; |
3099 | const auto unique_name = scope.GetUniqueNameForOp("Xdivy" ); |
3100 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Xdivy" ) |
3101 | .Input(_x) |
3102 | .Input(_y) |
3103 | ; |
3104 | scope.UpdateBuilder(&builder); |
3105 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3106 | if (!scope.ok()) return; |
3107 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3108 | this->operation = Operation(ret); |
3109 | this->z = Output(ret, 0); |
3110 | } |
3111 | |
3112 | Xlog1py::Xlog1py(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
3113 | ::tensorflow::Input y) { |
3114 | if (!scope.ok()) return; |
3115 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
3116 | if (!scope.ok()) return; |
3117 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
3118 | if (!scope.ok()) return; |
3119 | ::tensorflow::Node* ret; |
3120 | const auto unique_name = scope.GetUniqueNameForOp("Xlog1py" ); |
3121 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Xlog1py" ) |
3122 | .Input(_x) |
3123 | .Input(_y) |
3124 | ; |
3125 | scope.UpdateBuilder(&builder); |
3126 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3127 | if (!scope.ok()) return; |
3128 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3129 | this->operation = Operation(ret); |
3130 | this->z = Output(ret, 0); |
3131 | } |
3132 | |
3133 | Xlogy::Xlogy(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
3134 | ::tensorflow::Input y) { |
3135 | if (!scope.ok()) return; |
3136 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
3137 | if (!scope.ok()) return; |
3138 | auto _y = ::tensorflow::ops::AsNodeOut(scope, y); |
3139 | if (!scope.ok()) return; |
3140 | ::tensorflow::Node* ret; |
3141 | const auto unique_name = scope.GetUniqueNameForOp("Xlogy" ); |
3142 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Xlogy" ) |
3143 | .Input(_x) |
3144 | .Input(_y) |
3145 | ; |
3146 | scope.UpdateBuilder(&builder); |
3147 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3148 | if (!scope.ok()) return; |
3149 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3150 | this->operation = Operation(ret); |
3151 | this->z = Output(ret, 0); |
3152 | } |
3153 | |
3154 | Zeta::Zeta(const ::tensorflow::Scope& scope, ::tensorflow::Input x, |
3155 | ::tensorflow::Input q) { |
3156 | if (!scope.ok()) return; |
3157 | auto _x = ::tensorflow::ops::AsNodeOut(scope, x); |
3158 | if (!scope.ok()) return; |
3159 | auto _q = ::tensorflow::ops::AsNodeOut(scope, q); |
3160 | if (!scope.ok()) return; |
3161 | ::tensorflow::Node* ret; |
3162 | const auto unique_name = scope.GetUniqueNameForOp("Zeta" ); |
3163 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Zeta" ) |
3164 | .Input(_x) |
3165 | .Input(_q) |
3166 | ; |
3167 | scope.UpdateBuilder(&builder); |
3168 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3169 | if (!scope.ok()) return; |
3170 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3171 | this->operation = Operation(ret); |
3172 | this->z = Output(ret, 0); |
3173 | } |
3174 | |
3175 | /// @} |
3176 | |
3177 | } // namespace ops |
3178 | } // namespace tensorflow |
3179 | |