1 | // This file is MACHINE GENERATED! Do not edit. |
2 | |
3 | |
4 | #include "tensorflow/cc/ops/const_op.h" |
5 | #include "tensorflow/cc/ops/experimental_dataset_ops_internal.h" |
6 | |
7 | namespace tensorflow { |
8 | namespace ops { |
9 | namespace internal { |
10 | // NOTE: This namespace has internal TensorFlow details that |
11 | // are not part of TensorFlow's public API. |
12 | |
13 | AssertCardinalityDataset::AssertCardinalityDataset(const ::tensorflow::Scope& |
14 | scope, ::tensorflow::Input |
15 | input_dataset, |
16 | ::tensorflow::Input |
17 | cardinality, const |
18 | DataTypeSlice& output_types, |
19 | const |
20 | gtl::ArraySlice<PartialTensorShape>& |
21 | output_shapes) { |
22 | if (!scope.ok()) return; |
23 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
24 | if (!scope.ok()) return; |
25 | auto _cardinality = ::tensorflow::ops::AsNodeOut(scope, cardinality); |
26 | if (!scope.ok()) return; |
27 | ::tensorflow::Node* ret; |
28 | const auto unique_name = scope.GetUniqueNameForOp("AssertCardinalityDataset" ); |
29 | auto builder = ::tensorflow::NodeBuilder(unique_name, "AssertCardinalityDataset" ) |
30 | .Input(_input_dataset) |
31 | .Input(_cardinality) |
32 | .Attr("output_types" , output_types) |
33 | .Attr("output_shapes" , output_shapes) |
34 | ; |
35 | scope.UpdateBuilder(&builder); |
36 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
37 | if (!scope.ok()) return; |
38 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
39 | this->operation = Operation(ret); |
40 | this->handle = Output(ret, 0); |
41 | } |
42 | |
43 | AssertNextDataset::AssertNextDataset(const ::tensorflow::Scope& scope, |
44 | ::tensorflow::Input input_dataset, |
45 | ::tensorflow::Input transformations, const |
46 | DataTypeSlice& output_types, const |
47 | gtl::ArraySlice<PartialTensorShape>& |
48 | output_shapes) { |
49 | if (!scope.ok()) return; |
50 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
51 | if (!scope.ok()) return; |
52 | auto _transformations = ::tensorflow::ops::AsNodeOut(scope, transformations); |
53 | if (!scope.ok()) return; |
54 | ::tensorflow::Node* ret; |
55 | const auto unique_name = scope.GetUniqueNameForOp("AssertNextDataset" ); |
56 | auto builder = ::tensorflow::NodeBuilder(unique_name, "AssertNextDataset" ) |
57 | .Input(_input_dataset) |
58 | .Input(_transformations) |
59 | .Attr("output_types" , output_types) |
60 | .Attr("output_shapes" , output_shapes) |
61 | ; |
62 | scope.UpdateBuilder(&builder); |
63 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
64 | if (!scope.ok()) return; |
65 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
66 | this->operation = Operation(ret); |
67 | this->handle = Output(ret, 0); |
68 | } |
69 | |
70 | AssertPrevDataset::AssertPrevDataset(const ::tensorflow::Scope& scope, |
71 | ::tensorflow::Input input_dataset, |
72 | ::tensorflow::Input transformations, const |
73 | DataTypeSlice& output_types, const |
74 | gtl::ArraySlice<PartialTensorShape>& |
75 | output_shapes) { |
76 | if (!scope.ok()) return; |
77 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
78 | if (!scope.ok()) return; |
79 | auto _transformations = ::tensorflow::ops::AsNodeOut(scope, transformations); |
80 | if (!scope.ok()) return; |
81 | ::tensorflow::Node* ret; |
82 | const auto unique_name = scope.GetUniqueNameForOp("AssertPrevDataset" ); |
83 | auto builder = ::tensorflow::NodeBuilder(unique_name, "AssertPrevDataset" ) |
84 | .Input(_input_dataset) |
85 | .Input(_transformations) |
86 | .Attr("output_types" , output_types) |
87 | .Attr("output_shapes" , output_shapes) |
88 | ; |
89 | scope.UpdateBuilder(&builder); |
90 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
91 | if (!scope.ok()) return; |
92 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
93 | this->operation = Operation(ret); |
94 | this->handle = Output(ret, 0); |
95 | } |
96 | |
97 | AutoShardDataset::AutoShardDataset(const ::tensorflow::Scope& scope, |
98 | ::tensorflow::Input input_dataset, |
99 | ::tensorflow::Input num_workers, |
100 | ::tensorflow::Input index, const |
101 | DataTypeSlice& output_types, const |
102 | gtl::ArraySlice<PartialTensorShape>& |
103 | output_shapes, const |
104 | AutoShardDataset::Attrs& attrs) { |
105 | if (!scope.ok()) return; |
106 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
107 | if (!scope.ok()) return; |
108 | auto _num_workers = ::tensorflow::ops::AsNodeOut(scope, num_workers); |
109 | if (!scope.ok()) return; |
110 | auto _index = ::tensorflow::ops::AsNodeOut(scope, index); |
111 | if (!scope.ok()) return; |
112 | ::tensorflow::Node* ret; |
113 | const auto unique_name = scope.GetUniqueNameForOp("AutoShardDataset" ); |
114 | auto builder = ::tensorflow::NodeBuilder(unique_name, "AutoShardDataset" ) |
115 | .Input(_input_dataset) |
116 | .Input(_num_workers) |
117 | .Input(_index) |
118 | .Attr("auto_shard_policy" , attrs.auto_shard_policy_) |
119 | .Attr("output_types" , output_types) |
120 | .Attr("output_shapes" , output_shapes) |
121 | .Attr("num_replicas" , attrs.num_replicas_) |
122 | ; |
123 | scope.UpdateBuilder(&builder); |
124 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
125 | if (!scope.ok()) return; |
126 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
127 | this->operation = Operation(ret); |
128 | this->handle = Output(ret, 0); |
129 | } |
130 | |
131 | AutoShardDataset::AutoShardDataset(const ::tensorflow::Scope& scope, |
132 | ::tensorflow::Input input_dataset, |
133 | ::tensorflow::Input num_workers, |
134 | ::tensorflow::Input index, const |
135 | DataTypeSlice& output_types, const |
136 | gtl::ArraySlice<PartialTensorShape>& |
137 | output_shapes) |
138 | : AutoShardDataset(scope, input_dataset, num_workers, index, output_types, output_shapes, AutoShardDataset::Attrs()) {} |
139 | |
140 | BytesProducedStatsDataset::BytesProducedStatsDataset(const ::tensorflow::Scope& |
141 | scope, ::tensorflow::Input |
142 | input_dataset, |
143 | ::tensorflow::Input tag, |
144 | const DataTypeSlice& |
145 | output_types, const |
146 | gtl::ArraySlice<PartialTensorShape>& |
147 | output_shapes) { |
148 | if (!scope.ok()) return; |
149 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
150 | if (!scope.ok()) return; |
151 | auto _tag = ::tensorflow::ops::AsNodeOut(scope, tag); |
152 | if (!scope.ok()) return; |
153 | ::tensorflow::Node* ret; |
154 | const auto unique_name = scope.GetUniqueNameForOp("BytesProducedStatsDataset" ); |
155 | auto builder = ::tensorflow::NodeBuilder(unique_name, "BytesProducedStatsDataset" ) |
156 | .Input(_input_dataset) |
157 | .Input(_tag) |
158 | .Attr("output_types" , output_types) |
159 | .Attr("output_shapes" , output_shapes) |
160 | ; |
161 | scope.UpdateBuilder(&builder); |
162 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
163 | if (!scope.ok()) return; |
164 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
165 | this->operation = Operation(ret); |
166 | this->handle = Output(ret, 0); |
167 | } |
168 | |
169 | CSVDataset::CSVDataset(const ::tensorflow::Scope& scope, ::tensorflow::Input |
170 | filenames, ::tensorflow::Input compression_type, |
171 | ::tensorflow::Input buffer_size, ::tensorflow::Input |
172 | , ::tensorflow::Input field_delim, |
173 | ::tensorflow::Input use_quote_delim, ::tensorflow::Input |
174 | na_value, ::tensorflow::Input select_cols, |
175 | ::tensorflow::InputList record_defaults, const |
176 | gtl::ArraySlice<PartialTensorShape>& output_shapes) { |
177 | if (!scope.ok()) return; |
178 | auto _filenames = ::tensorflow::ops::AsNodeOut(scope, filenames); |
179 | if (!scope.ok()) return; |
180 | auto _compression_type = ::tensorflow::ops::AsNodeOut(scope, compression_type); |
181 | if (!scope.ok()) return; |
182 | auto _buffer_size = ::tensorflow::ops::AsNodeOut(scope, buffer_size); |
183 | if (!scope.ok()) return; |
184 | auto = ::tensorflow::ops::AsNodeOut(scope, header); |
185 | if (!scope.ok()) return; |
186 | auto _field_delim = ::tensorflow::ops::AsNodeOut(scope, field_delim); |
187 | if (!scope.ok()) return; |
188 | auto _use_quote_delim = ::tensorflow::ops::AsNodeOut(scope, use_quote_delim); |
189 | if (!scope.ok()) return; |
190 | auto _na_value = ::tensorflow::ops::AsNodeOut(scope, na_value); |
191 | if (!scope.ok()) return; |
192 | auto _select_cols = ::tensorflow::ops::AsNodeOut(scope, select_cols); |
193 | if (!scope.ok()) return; |
194 | auto _record_defaults = ::tensorflow::ops::AsNodeOutList(scope, record_defaults); |
195 | if (!scope.ok()) return; |
196 | ::tensorflow::Node* ret; |
197 | const auto unique_name = scope.GetUniqueNameForOp("CSVDataset" ); |
198 | auto builder = ::tensorflow::NodeBuilder(unique_name, "CSVDataset" ) |
199 | .Input(_filenames) |
200 | .Input(_compression_type) |
201 | .Input(_buffer_size) |
202 | .Input(_header) |
203 | .Input(_field_delim) |
204 | .Input(_use_quote_delim) |
205 | .Input(_na_value) |
206 | .Input(_select_cols) |
207 | .Input(_record_defaults) |
208 | .Attr("output_shapes" , output_shapes) |
209 | ; |
210 | scope.UpdateBuilder(&builder); |
211 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
212 | if (!scope.ok()) return; |
213 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
214 | this->operation = Operation(ret); |
215 | this->handle = Output(ret, 0); |
216 | } |
217 | |
218 | CSVDatasetV2::CSVDatasetV2(const ::tensorflow::Scope& scope, |
219 | ::tensorflow::Input filenames, ::tensorflow::Input |
220 | compression_type, ::tensorflow::Input buffer_size, |
221 | ::tensorflow::Input , ::tensorflow::Input |
222 | field_delim, ::tensorflow::Input use_quote_delim, |
223 | ::tensorflow::Input na_value, ::tensorflow::Input |
224 | select_cols, ::tensorflow::InputList |
225 | record_defaults, ::tensorflow::Input exclude_cols, |
226 | const gtl::ArraySlice<PartialTensorShape>& |
227 | output_shapes) { |
228 | if (!scope.ok()) return; |
229 | auto _filenames = ::tensorflow::ops::AsNodeOut(scope, filenames); |
230 | if (!scope.ok()) return; |
231 | auto _compression_type = ::tensorflow::ops::AsNodeOut(scope, compression_type); |
232 | if (!scope.ok()) return; |
233 | auto _buffer_size = ::tensorflow::ops::AsNodeOut(scope, buffer_size); |
234 | if (!scope.ok()) return; |
235 | auto = ::tensorflow::ops::AsNodeOut(scope, header); |
236 | if (!scope.ok()) return; |
237 | auto _field_delim = ::tensorflow::ops::AsNodeOut(scope, field_delim); |
238 | if (!scope.ok()) return; |
239 | auto _use_quote_delim = ::tensorflow::ops::AsNodeOut(scope, use_quote_delim); |
240 | if (!scope.ok()) return; |
241 | auto _na_value = ::tensorflow::ops::AsNodeOut(scope, na_value); |
242 | if (!scope.ok()) return; |
243 | auto _select_cols = ::tensorflow::ops::AsNodeOut(scope, select_cols); |
244 | if (!scope.ok()) return; |
245 | auto _record_defaults = ::tensorflow::ops::AsNodeOutList(scope, record_defaults); |
246 | if (!scope.ok()) return; |
247 | auto _exclude_cols = ::tensorflow::ops::AsNodeOut(scope, exclude_cols); |
248 | if (!scope.ok()) return; |
249 | ::tensorflow::Node* ret; |
250 | const auto unique_name = scope.GetUniqueNameForOp("CSVDatasetV2" ); |
251 | auto builder = ::tensorflow::NodeBuilder(unique_name, "CSVDatasetV2" ) |
252 | .Input(_filenames) |
253 | .Input(_compression_type) |
254 | .Input(_buffer_size) |
255 | .Input(_header) |
256 | .Input(_field_delim) |
257 | .Input(_use_quote_delim) |
258 | .Input(_na_value) |
259 | .Input(_select_cols) |
260 | .Input(_record_defaults) |
261 | .Input(_exclude_cols) |
262 | .Attr("output_shapes" , output_shapes) |
263 | ; |
264 | scope.UpdateBuilder(&builder); |
265 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
266 | if (!scope.ok()) return; |
267 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
268 | this->operation = Operation(ret); |
269 | this->handle = Output(ret, 0); |
270 | } |
271 | |
272 | ChooseFastestBranchDataset::ChooseFastestBranchDataset(const |
273 | ::tensorflow::Scope& |
274 | scope, |
275 | ::tensorflow::Input |
276 | input_dataset, |
277 | ::tensorflow::Input |
278 | ratio_numerator, |
279 | ::tensorflow::Input |
280 | ratio_denominator, |
281 | ::tensorflow::InputList |
282 | other_arguments, int64 |
283 | num_elements_per_branch, |
284 | const |
285 | gtl::ArraySlice<NameAttrList>& |
286 | branches, const |
287 | gtl::ArraySlice<int>& |
288 | other_arguments_lengths, |
289 | const DataTypeSlice& |
290 | output_types, const |
291 | gtl::ArraySlice<PartialTensorShape>& |
292 | output_shapes) { |
293 | if (!scope.ok()) return; |
294 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
295 | if (!scope.ok()) return; |
296 | auto _ratio_numerator = ::tensorflow::ops::AsNodeOut(scope, ratio_numerator); |
297 | if (!scope.ok()) return; |
298 | auto _ratio_denominator = ::tensorflow::ops::AsNodeOut(scope, ratio_denominator); |
299 | if (!scope.ok()) return; |
300 | auto _other_arguments = ::tensorflow::ops::AsNodeOutList(scope, other_arguments); |
301 | if (!scope.ok()) return; |
302 | ::tensorflow::Node* ret; |
303 | const auto unique_name = scope.GetUniqueNameForOp("ChooseFastestBranchDataset" ); |
304 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ChooseFastestBranchDataset" ) |
305 | .Input(_input_dataset) |
306 | .Input(_ratio_numerator) |
307 | .Input(_ratio_denominator) |
308 | .Input(_other_arguments) |
309 | .Attr("num_elements_per_branch" , num_elements_per_branch) |
310 | .Attr("branches" , branches) |
311 | .Attr("other_arguments_lengths" , other_arguments_lengths) |
312 | .Attr("output_types" , output_types) |
313 | .Attr("output_shapes" , output_shapes) |
314 | ; |
315 | scope.UpdateBuilder(&builder); |
316 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
317 | if (!scope.ok()) return; |
318 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
319 | this->operation = Operation(ret); |
320 | this->handle = Output(ret, 0); |
321 | } |
322 | |
323 | ChooseFastestDataset::ChooseFastestDataset(const ::tensorflow::Scope& scope, |
324 | ::tensorflow::InputList |
325 | input_datasets, int64 |
326 | num_experiments, const |
327 | DataTypeSlice& output_types, const |
328 | gtl::ArraySlice<PartialTensorShape>& |
329 | output_shapes) { |
330 | if (!scope.ok()) return; |
331 | auto _input_datasets = ::tensorflow::ops::AsNodeOutList(scope, input_datasets); |
332 | if (!scope.ok()) return; |
333 | ::tensorflow::Node* ret; |
334 | const auto unique_name = scope.GetUniqueNameForOp("ChooseFastestDataset" ); |
335 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ChooseFastestDataset" ) |
336 | .Input(_input_datasets) |
337 | .Attr("num_experiments" , num_experiments) |
338 | .Attr("output_types" , output_types) |
339 | .Attr("output_shapes" , output_shapes) |
340 | ; |
341 | scope.UpdateBuilder(&builder); |
342 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
343 | if (!scope.ok()) return; |
344 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
345 | this->operation = Operation(ret); |
346 | this->handle = Output(ret, 0); |
347 | } |
348 | |
349 | CompressElement::CompressElement(const ::tensorflow::Scope& scope, |
350 | ::tensorflow::InputList components) { |
351 | if (!scope.ok()) return; |
352 | auto _components = ::tensorflow::ops::AsNodeOutList(scope, components); |
353 | if (!scope.ok()) return; |
354 | ::tensorflow::Node* ret; |
355 | const auto unique_name = scope.GetUniqueNameForOp("CompressElement" ); |
356 | auto builder = ::tensorflow::NodeBuilder(unique_name, "CompressElement" ) |
357 | .Input(_components) |
358 | ; |
359 | scope.UpdateBuilder(&builder); |
360 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
361 | if (!scope.ok()) return; |
362 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
363 | this->operation = Operation(ret); |
364 | this->compressed = Output(ret, 0); |
365 | } |
366 | |
367 | ComputeBatchSize::ComputeBatchSize(const ::tensorflow::Scope& scope, |
368 | ::tensorflow::Input input_dataset) { |
369 | if (!scope.ok()) return; |
370 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
371 | if (!scope.ok()) return; |
372 | ::tensorflow::Node* ret; |
373 | const auto unique_name = scope.GetUniqueNameForOp("ComputeBatchSize" ); |
374 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ComputeBatchSize" ) |
375 | .Input(_input_dataset) |
376 | ; |
377 | scope.UpdateBuilder(&builder); |
378 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
379 | if (!scope.ok()) return; |
380 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
381 | this->operation = Operation(ret); |
382 | this->batch_size = Output(ret, 0); |
383 | } |
384 | |
385 | DataServiceDataset::DataServiceDataset(const ::tensorflow::Scope& scope, |
386 | ::tensorflow::Input dataset_id, |
387 | ::tensorflow::Input processing_mode, |
388 | ::tensorflow::Input address, |
389 | ::tensorflow::Input protocol, |
390 | ::tensorflow::Input job_name, |
391 | ::tensorflow::Input |
392 | max_outstanding_requests, |
393 | ::tensorflow::Input iteration_counter, |
394 | const DataTypeSlice& output_types, const |
395 | gtl::ArraySlice<PartialTensorShape>& |
396 | output_shapes, const |
397 | DataServiceDataset::Attrs& attrs) { |
398 | if (!scope.ok()) return; |
399 | auto _dataset_id = ::tensorflow::ops::AsNodeOut(scope, dataset_id); |
400 | if (!scope.ok()) return; |
401 | auto _processing_mode = ::tensorflow::ops::AsNodeOut(scope, processing_mode); |
402 | if (!scope.ok()) return; |
403 | auto _address = ::tensorflow::ops::AsNodeOut(scope, address); |
404 | if (!scope.ok()) return; |
405 | auto _protocol = ::tensorflow::ops::AsNodeOut(scope, protocol); |
406 | if (!scope.ok()) return; |
407 | auto _job_name = ::tensorflow::ops::AsNodeOut(scope, job_name); |
408 | if (!scope.ok()) return; |
409 | auto _max_outstanding_requests = ::tensorflow::ops::AsNodeOut(scope, max_outstanding_requests); |
410 | if (!scope.ok()) return; |
411 | auto _iteration_counter = ::tensorflow::ops::AsNodeOut(scope, iteration_counter); |
412 | if (!scope.ok()) return; |
413 | ::tensorflow::Node* ret; |
414 | const auto unique_name = scope.GetUniqueNameForOp("DataServiceDataset" ); |
415 | auto builder = ::tensorflow::NodeBuilder(unique_name, "DataServiceDataset" ) |
416 | .Input(_dataset_id) |
417 | .Input(_processing_mode) |
418 | .Input(_address) |
419 | .Input(_protocol) |
420 | .Input(_job_name) |
421 | .Input(_max_outstanding_requests) |
422 | .Input(_iteration_counter) |
423 | .Attr("task_refresh_interval_hint_ms" , attrs.task_refresh_interval_hint_ms_) |
424 | .Attr("output_types" , output_types) |
425 | .Attr("output_shapes" , output_shapes) |
426 | .Attr("data_transfer_protocol" , attrs.data_transfer_protocol_) |
427 | .Attr("target_workers" , attrs.target_workers_) |
428 | .Attr("cross_trainer_cache_options" , attrs.cross_trainer_cache_options_) |
429 | ; |
430 | scope.UpdateBuilder(&builder); |
431 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
432 | if (!scope.ok()) return; |
433 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
434 | this->operation = Operation(ret); |
435 | this->handle = Output(ret, 0); |
436 | } |
437 | |
438 | DataServiceDataset::DataServiceDataset(const ::tensorflow::Scope& scope, |
439 | ::tensorflow::Input dataset_id, |
440 | ::tensorflow::Input processing_mode, |
441 | ::tensorflow::Input address, |
442 | ::tensorflow::Input protocol, |
443 | ::tensorflow::Input job_name, |
444 | ::tensorflow::Input |
445 | max_outstanding_requests, |
446 | ::tensorflow::Input iteration_counter, |
447 | const DataTypeSlice& output_types, const |
448 | gtl::ArraySlice<PartialTensorShape>& |
449 | output_shapes) |
450 | : DataServiceDataset(scope, dataset_id, processing_mode, address, protocol, job_name, max_outstanding_requests, iteration_counter, output_types, output_shapes, DataServiceDataset::Attrs()) {} |
451 | |
452 | DataServiceDatasetV2::DataServiceDatasetV2(const ::tensorflow::Scope& scope, |
453 | ::tensorflow::Input dataset_id, |
454 | ::tensorflow::Input processing_mode, |
455 | ::tensorflow::Input address, |
456 | ::tensorflow::Input protocol, |
457 | ::tensorflow::Input job_name, |
458 | ::tensorflow::Input consumer_index, |
459 | ::tensorflow::Input num_consumers, |
460 | ::tensorflow::Input |
461 | max_outstanding_requests, |
462 | ::tensorflow::Input |
463 | iteration_counter, const |
464 | DataTypeSlice& output_types, const |
465 | gtl::ArraySlice<PartialTensorShape>& |
466 | output_shapes, const |
467 | DataServiceDatasetV2::Attrs& attrs) { |
468 | if (!scope.ok()) return; |
469 | auto _dataset_id = ::tensorflow::ops::AsNodeOut(scope, dataset_id); |
470 | if (!scope.ok()) return; |
471 | auto _processing_mode = ::tensorflow::ops::AsNodeOut(scope, processing_mode); |
472 | if (!scope.ok()) return; |
473 | auto _address = ::tensorflow::ops::AsNodeOut(scope, address); |
474 | if (!scope.ok()) return; |
475 | auto _protocol = ::tensorflow::ops::AsNodeOut(scope, protocol); |
476 | if (!scope.ok()) return; |
477 | auto _job_name = ::tensorflow::ops::AsNodeOut(scope, job_name); |
478 | if (!scope.ok()) return; |
479 | auto _consumer_index = ::tensorflow::ops::AsNodeOut(scope, consumer_index); |
480 | if (!scope.ok()) return; |
481 | auto _num_consumers = ::tensorflow::ops::AsNodeOut(scope, num_consumers); |
482 | if (!scope.ok()) return; |
483 | auto _max_outstanding_requests = ::tensorflow::ops::AsNodeOut(scope, max_outstanding_requests); |
484 | if (!scope.ok()) return; |
485 | auto _iteration_counter = ::tensorflow::ops::AsNodeOut(scope, iteration_counter); |
486 | if (!scope.ok()) return; |
487 | ::tensorflow::Node* ret; |
488 | const auto unique_name = scope.GetUniqueNameForOp("DataServiceDatasetV2" ); |
489 | auto builder = ::tensorflow::NodeBuilder(unique_name, "DataServiceDatasetV2" ) |
490 | .Input(_dataset_id) |
491 | .Input(_processing_mode) |
492 | .Input(_address) |
493 | .Input(_protocol) |
494 | .Input(_job_name) |
495 | .Input(_consumer_index) |
496 | .Input(_num_consumers) |
497 | .Input(_max_outstanding_requests) |
498 | .Input(_iteration_counter) |
499 | .Attr("task_refresh_interval_hint_ms" , attrs.task_refresh_interval_hint_ms_) |
500 | .Attr("output_types" , output_types) |
501 | .Attr("output_shapes" , output_shapes) |
502 | .Attr("data_transfer_protocol" , attrs.data_transfer_protocol_) |
503 | .Attr("target_workers" , attrs.target_workers_) |
504 | .Attr("cross_trainer_cache_options" , attrs.cross_trainer_cache_options_) |
505 | ; |
506 | scope.UpdateBuilder(&builder); |
507 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
508 | if (!scope.ok()) return; |
509 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
510 | this->operation = Operation(ret); |
511 | this->handle = Output(ret, 0); |
512 | } |
513 | |
514 | DataServiceDatasetV2::DataServiceDatasetV2(const ::tensorflow::Scope& scope, |
515 | ::tensorflow::Input dataset_id, |
516 | ::tensorflow::Input processing_mode, |
517 | ::tensorflow::Input address, |
518 | ::tensorflow::Input protocol, |
519 | ::tensorflow::Input job_name, |
520 | ::tensorflow::Input consumer_index, |
521 | ::tensorflow::Input num_consumers, |
522 | ::tensorflow::Input |
523 | max_outstanding_requests, |
524 | ::tensorflow::Input |
525 | iteration_counter, const |
526 | DataTypeSlice& output_types, const |
527 | gtl::ArraySlice<PartialTensorShape>& |
528 | output_shapes) |
529 | : DataServiceDatasetV2(scope, dataset_id, processing_mode, address, protocol, job_name, consumer_index, num_consumers, max_outstanding_requests, iteration_counter, output_types, output_shapes, DataServiceDatasetV2::Attrs()) {} |
530 | |
531 | DataServiceDatasetV3::DataServiceDatasetV3(const ::tensorflow::Scope& scope, |
532 | ::tensorflow::Input dataset_id, |
533 | ::tensorflow::Input processing_mode, |
534 | ::tensorflow::Input address, |
535 | ::tensorflow::Input protocol, |
536 | ::tensorflow::Input job_name, |
537 | ::tensorflow::Input consumer_index, |
538 | ::tensorflow::Input num_consumers, |
539 | ::tensorflow::Input |
540 | max_outstanding_requests, |
541 | ::tensorflow::Input |
542 | iteration_counter, const |
543 | DataTypeSlice& output_types, const |
544 | gtl::ArraySlice<PartialTensorShape>& |
545 | output_shapes, const NameAttrList& |
546 | uncompress_fn, const |
547 | DataServiceDatasetV3::Attrs& attrs) { |
548 | if (!scope.ok()) return; |
549 | auto _dataset_id = ::tensorflow::ops::AsNodeOut(scope, dataset_id); |
550 | if (!scope.ok()) return; |
551 | auto _processing_mode = ::tensorflow::ops::AsNodeOut(scope, processing_mode); |
552 | if (!scope.ok()) return; |
553 | auto _address = ::tensorflow::ops::AsNodeOut(scope, address); |
554 | if (!scope.ok()) return; |
555 | auto _protocol = ::tensorflow::ops::AsNodeOut(scope, protocol); |
556 | if (!scope.ok()) return; |
557 | auto _job_name = ::tensorflow::ops::AsNodeOut(scope, job_name); |
558 | if (!scope.ok()) return; |
559 | auto _consumer_index = ::tensorflow::ops::AsNodeOut(scope, consumer_index); |
560 | if (!scope.ok()) return; |
561 | auto _num_consumers = ::tensorflow::ops::AsNodeOut(scope, num_consumers); |
562 | if (!scope.ok()) return; |
563 | auto _max_outstanding_requests = ::tensorflow::ops::AsNodeOut(scope, max_outstanding_requests); |
564 | if (!scope.ok()) return; |
565 | auto _iteration_counter = ::tensorflow::ops::AsNodeOut(scope, iteration_counter); |
566 | if (!scope.ok()) return; |
567 | ::tensorflow::Node* ret; |
568 | const auto unique_name = scope.GetUniqueNameForOp("DataServiceDatasetV3" ); |
569 | auto builder = ::tensorflow::NodeBuilder(unique_name, "DataServiceDatasetV3" ) |
570 | .Input(_dataset_id) |
571 | .Input(_processing_mode) |
572 | .Input(_address) |
573 | .Input(_protocol) |
574 | .Input(_job_name) |
575 | .Input(_consumer_index) |
576 | .Input(_num_consumers) |
577 | .Input(_max_outstanding_requests) |
578 | .Input(_iteration_counter) |
579 | .Attr("task_refresh_interval_hint_ms" , attrs.task_refresh_interval_hint_ms_) |
580 | .Attr("output_types" , output_types) |
581 | .Attr("output_shapes" , output_shapes) |
582 | .Attr("data_transfer_protocol" , attrs.data_transfer_protocol_) |
583 | .Attr("target_workers" , attrs.target_workers_) |
584 | .Attr("uncompress" , attrs.uncompress_) |
585 | .Attr("uncompress_fn" , uncompress_fn) |
586 | .Attr("cross_trainer_cache_options" , attrs.cross_trainer_cache_options_) |
587 | ; |
588 | scope.UpdateBuilder(&builder); |
589 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
590 | if (!scope.ok()) return; |
591 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
592 | this->operation = Operation(ret); |
593 | this->handle = Output(ret, 0); |
594 | } |
595 | |
596 | DataServiceDatasetV3::DataServiceDatasetV3(const ::tensorflow::Scope& scope, |
597 | ::tensorflow::Input dataset_id, |
598 | ::tensorflow::Input processing_mode, |
599 | ::tensorflow::Input address, |
600 | ::tensorflow::Input protocol, |
601 | ::tensorflow::Input job_name, |
602 | ::tensorflow::Input consumer_index, |
603 | ::tensorflow::Input num_consumers, |
604 | ::tensorflow::Input |
605 | max_outstanding_requests, |
606 | ::tensorflow::Input |
607 | iteration_counter, const |
608 | DataTypeSlice& output_types, const |
609 | gtl::ArraySlice<PartialTensorShape>& |
610 | output_shapes, const NameAttrList& |
611 | uncompress_fn) |
612 | : DataServiceDatasetV3(scope, dataset_id, processing_mode, address, protocol, job_name, consumer_index, num_consumers, max_outstanding_requests, iteration_counter, output_types, output_shapes, uncompress_fn, DataServiceDatasetV3::Attrs()) {} |
613 | |
614 | DataServiceDatasetV4::DataServiceDatasetV4(const ::tensorflow::Scope& scope, |
615 | ::tensorflow::Input dataset_id, |
616 | ::tensorflow::Input processing_mode, |
617 | ::tensorflow::Input address, |
618 | ::tensorflow::Input protocol, |
619 | ::tensorflow::Input job_name, |
620 | ::tensorflow::Input consumer_index, |
621 | ::tensorflow::Input num_consumers, |
622 | ::tensorflow::Input |
623 | max_outstanding_requests, |
624 | ::tensorflow::Input |
625 | iteration_counter, const |
626 | DataTypeSlice& output_types, const |
627 | gtl::ArraySlice<PartialTensorShape>& |
628 | output_shapes, const NameAttrList& |
629 | uncompress_fn, const |
630 | DataServiceDatasetV4::Attrs& attrs) { |
631 | if (!scope.ok()) return; |
632 | auto _dataset_id = ::tensorflow::ops::AsNodeOut(scope, dataset_id); |
633 | if (!scope.ok()) return; |
634 | auto _processing_mode = ::tensorflow::ops::AsNodeOut(scope, processing_mode); |
635 | if (!scope.ok()) return; |
636 | auto _address = ::tensorflow::ops::AsNodeOut(scope, address); |
637 | if (!scope.ok()) return; |
638 | auto _protocol = ::tensorflow::ops::AsNodeOut(scope, protocol); |
639 | if (!scope.ok()) return; |
640 | auto _job_name = ::tensorflow::ops::AsNodeOut(scope, job_name); |
641 | if (!scope.ok()) return; |
642 | auto _consumer_index = ::tensorflow::ops::AsNodeOut(scope, consumer_index); |
643 | if (!scope.ok()) return; |
644 | auto _num_consumers = ::tensorflow::ops::AsNodeOut(scope, num_consumers); |
645 | if (!scope.ok()) return; |
646 | auto _max_outstanding_requests = ::tensorflow::ops::AsNodeOut(scope, max_outstanding_requests); |
647 | if (!scope.ok()) return; |
648 | auto _iteration_counter = ::tensorflow::ops::AsNodeOut(scope, iteration_counter); |
649 | if (!scope.ok()) return; |
650 | ::tensorflow::Node* ret; |
651 | const auto unique_name = scope.GetUniqueNameForOp("DataServiceDatasetV4" ); |
652 | auto builder = ::tensorflow::NodeBuilder(unique_name, "DataServiceDatasetV4" ) |
653 | .Input(_dataset_id) |
654 | .Input(_processing_mode) |
655 | .Input(_address) |
656 | .Input(_protocol) |
657 | .Input(_job_name) |
658 | .Input(_consumer_index) |
659 | .Input(_num_consumers) |
660 | .Input(_max_outstanding_requests) |
661 | .Input(_iteration_counter) |
662 | .Attr("task_refresh_interval_hint_ms" , attrs.task_refresh_interval_hint_ms_) |
663 | .Attr("output_types" , output_types) |
664 | .Attr("output_shapes" , output_shapes) |
665 | .Attr("data_transfer_protocol" , attrs.data_transfer_protocol_) |
666 | .Attr("target_workers" , attrs.target_workers_) |
667 | .Attr("uncompress" , attrs.uncompress_) |
668 | .Attr("uncompress_fn" , uncompress_fn) |
669 | .Attr("cross_trainer_cache_options" , attrs.cross_trainer_cache_options_) |
670 | ; |
671 | scope.UpdateBuilder(&builder); |
672 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
673 | if (!scope.ok()) return; |
674 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
675 | this->operation = Operation(ret); |
676 | this->handle = Output(ret, 0); |
677 | } |
678 | |
679 | DataServiceDatasetV4::DataServiceDatasetV4(const ::tensorflow::Scope& scope, |
680 | ::tensorflow::Input dataset_id, |
681 | ::tensorflow::Input processing_mode, |
682 | ::tensorflow::Input address, |
683 | ::tensorflow::Input protocol, |
684 | ::tensorflow::Input job_name, |
685 | ::tensorflow::Input consumer_index, |
686 | ::tensorflow::Input num_consumers, |
687 | ::tensorflow::Input |
688 | max_outstanding_requests, |
689 | ::tensorflow::Input |
690 | iteration_counter, const |
691 | DataTypeSlice& output_types, const |
692 | gtl::ArraySlice<PartialTensorShape>& |
693 | output_shapes, const NameAttrList& |
694 | uncompress_fn) |
695 | : DataServiceDatasetV4(scope, dataset_id, processing_mode, address, protocol, job_name, consumer_index, num_consumers, max_outstanding_requests, iteration_counter, output_types, output_shapes, uncompress_fn, DataServiceDatasetV4::Attrs()) {} |
696 | |
697 | DatasetFromGraph::DatasetFromGraph(const ::tensorflow::Scope& scope, |
698 | ::tensorflow::Input graph_def) { |
699 | if (!scope.ok()) return; |
700 | auto _graph_def = ::tensorflow::ops::AsNodeOut(scope, graph_def); |
701 | if (!scope.ok()) return; |
702 | ::tensorflow::Node* ret; |
703 | const auto unique_name = scope.GetUniqueNameForOp("DatasetFromGraph" ); |
704 | auto builder = ::tensorflow::NodeBuilder(unique_name, "DatasetFromGraph" ) |
705 | .Input(_graph_def) |
706 | ; |
707 | scope.UpdateBuilder(&builder); |
708 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
709 | if (!scope.ok()) return; |
710 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
711 | this->operation = Operation(ret); |
712 | this->handle = Output(ret, 0); |
713 | } |
714 | |
715 | DatasetToTFRecord::DatasetToTFRecord(const ::tensorflow::Scope& scope, |
716 | ::tensorflow::Input input_dataset, |
717 | ::tensorflow::Input filename, |
718 | ::tensorflow::Input compression_type) { |
719 | if (!scope.ok()) return; |
720 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
721 | if (!scope.ok()) return; |
722 | auto _filename = ::tensorflow::ops::AsNodeOut(scope, filename); |
723 | if (!scope.ok()) return; |
724 | auto _compression_type = ::tensorflow::ops::AsNodeOut(scope, compression_type); |
725 | if (!scope.ok()) return; |
726 | ::tensorflow::Node* ret; |
727 | const auto unique_name = scope.GetUniqueNameForOp("DatasetToTFRecord" ); |
728 | auto builder = ::tensorflow::NodeBuilder(unique_name, "DatasetToTFRecord" ) |
729 | .Input(_input_dataset) |
730 | .Input(_filename) |
731 | .Input(_compression_type) |
732 | ; |
733 | scope.UpdateBuilder(&builder); |
734 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
735 | if (!scope.ok()) return; |
736 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
737 | this->operation = Operation(ret); |
738 | return; |
739 | } |
740 | |
741 | DenseToSparseBatchDataset::DenseToSparseBatchDataset(const ::tensorflow::Scope& |
742 | scope, ::tensorflow::Input |
743 | input_dataset, |
744 | ::tensorflow::Input |
745 | batch_size, |
746 | ::tensorflow::Input |
747 | row_shape, const |
748 | DataTypeSlice& |
749 | output_types, const |
750 | gtl::ArraySlice<PartialTensorShape>& |
751 | output_shapes) { |
752 | if (!scope.ok()) return; |
753 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
754 | if (!scope.ok()) return; |
755 | auto _batch_size = ::tensorflow::ops::AsNodeOut(scope, batch_size); |
756 | if (!scope.ok()) return; |
757 | auto _row_shape = ::tensorflow::ops::AsNodeOut(scope, row_shape); |
758 | if (!scope.ok()) return; |
759 | ::tensorflow::Node* ret; |
760 | const auto unique_name = scope.GetUniqueNameForOp("DenseToSparseBatchDataset" ); |
761 | auto builder = ::tensorflow::NodeBuilder(unique_name, "DenseToSparseBatchDataset" ) |
762 | .Input(_input_dataset) |
763 | .Input(_batch_size) |
764 | .Input(_row_shape) |
765 | .Attr("output_types" , output_types) |
766 | .Attr("output_shapes" , output_shapes) |
767 | ; |
768 | scope.UpdateBuilder(&builder); |
769 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
770 | if (!scope.ok()) return; |
771 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
772 | this->operation = Operation(ret); |
773 | this->handle = Output(ret, 0); |
774 | } |
775 | |
776 | DirectedInterleaveDataset::DirectedInterleaveDataset(const ::tensorflow::Scope& |
777 | scope, ::tensorflow::Input |
778 | selector_input_dataset, |
779 | ::tensorflow::InputList |
780 | data_input_datasets, const |
781 | DataTypeSlice& |
782 | output_types, const |
783 | gtl::ArraySlice<PartialTensorShape>& |
784 | output_shapes, const |
785 | DirectedInterleaveDataset::Attrs& |
786 | attrs) { |
787 | if (!scope.ok()) return; |
788 | auto _selector_input_dataset = ::tensorflow::ops::AsNodeOut(scope, selector_input_dataset); |
789 | if (!scope.ok()) return; |
790 | auto _data_input_datasets = ::tensorflow::ops::AsNodeOutList(scope, data_input_datasets); |
791 | if (!scope.ok()) return; |
792 | ::tensorflow::Node* ret; |
793 | const auto unique_name = scope.GetUniqueNameForOp("DirectedInterleaveDataset" ); |
794 | auto builder = ::tensorflow::NodeBuilder(unique_name, "DirectedInterleaveDataset" ) |
795 | .Input(_selector_input_dataset) |
796 | .Input(_data_input_datasets) |
797 | .Attr("output_types" , output_types) |
798 | .Attr("output_shapes" , output_shapes) |
799 | .Attr("stop_on_empty_dataset" , attrs.stop_on_empty_dataset_) |
800 | ; |
801 | scope.UpdateBuilder(&builder); |
802 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
803 | if (!scope.ok()) return; |
804 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
805 | this->operation = Operation(ret); |
806 | this->handle = Output(ret, 0); |
807 | } |
808 | |
809 | DirectedInterleaveDataset::DirectedInterleaveDataset(const ::tensorflow::Scope& |
810 | scope, ::tensorflow::Input |
811 | selector_input_dataset, |
812 | ::tensorflow::InputList |
813 | data_input_datasets, const |
814 | DataTypeSlice& |
815 | output_types, const |
816 | gtl::ArraySlice<PartialTensorShape>& |
817 | output_shapes) |
818 | : DirectedInterleaveDataset(scope, selector_input_dataset, data_input_datasets, output_types, output_shapes, DirectedInterleaveDataset::Attrs()) {} |
819 | |
820 | DummyIterationCounter::DummyIterationCounter(const ::tensorflow::Scope& scope) { |
821 | if (!scope.ok()) return; |
822 | ::tensorflow::Node* ret; |
823 | const auto unique_name = scope.GetUniqueNameForOp("DummyIterationCounter" ); |
824 | auto builder = ::tensorflow::NodeBuilder(unique_name, "DummyIterationCounter" ) |
825 | ; |
826 | scope.UpdateBuilder(&builder); |
827 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
828 | if (!scope.ok()) return; |
829 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
830 | this->operation = Operation(ret); |
831 | this->handle = Output(ret, 0); |
832 | } |
833 | |
834 | ExperimentalAssertNextDataset::ExperimentalAssertNextDataset(const |
835 | ::tensorflow::Scope& |
836 | scope, |
837 | ::tensorflow::Input |
838 | input_dataset, |
839 | ::tensorflow::Input |
840 | transformations, |
841 | const |
842 | DataTypeSlice& |
843 | output_types, |
844 | const |
845 | gtl::ArraySlice<PartialTensorShape>& |
846 | output_shapes) { |
847 | if (!scope.ok()) return; |
848 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
849 | if (!scope.ok()) return; |
850 | auto _transformations = ::tensorflow::ops::AsNodeOut(scope, transformations); |
851 | if (!scope.ok()) return; |
852 | ::tensorflow::Node* ret; |
853 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalAssertNextDataset" ); |
854 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalAssertNextDataset" ) |
855 | .Input(_input_dataset) |
856 | .Input(_transformations) |
857 | .Attr("output_types" , output_types) |
858 | .Attr("output_shapes" , output_shapes) |
859 | ; |
860 | scope.UpdateBuilder(&builder); |
861 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
862 | if (!scope.ok()) return; |
863 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
864 | this->operation = Operation(ret); |
865 | this->handle = Output(ret, 0); |
866 | } |
867 | |
868 | ExperimentalAutoShardDataset::ExperimentalAutoShardDataset(const |
869 | ::tensorflow::Scope& |
870 | scope, |
871 | ::tensorflow::Input |
872 | input_dataset, |
873 | ::tensorflow::Input |
874 | num_workers, |
875 | ::tensorflow::Input |
876 | index, const |
877 | DataTypeSlice& |
878 | output_types, const |
879 | gtl::ArraySlice<PartialTensorShape>& |
880 | output_shapes, const |
881 | ExperimentalAutoShardDataset::Attrs& |
882 | attrs) { |
883 | if (!scope.ok()) return; |
884 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
885 | if (!scope.ok()) return; |
886 | auto _num_workers = ::tensorflow::ops::AsNodeOut(scope, num_workers); |
887 | if (!scope.ok()) return; |
888 | auto _index = ::tensorflow::ops::AsNodeOut(scope, index); |
889 | if (!scope.ok()) return; |
890 | ::tensorflow::Node* ret; |
891 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalAutoShardDataset" ); |
892 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalAutoShardDataset" ) |
893 | .Input(_input_dataset) |
894 | .Input(_num_workers) |
895 | .Input(_index) |
896 | .Attr("auto_shard_policy" , attrs.auto_shard_policy_) |
897 | .Attr("output_types" , output_types) |
898 | .Attr("output_shapes" , output_shapes) |
899 | ; |
900 | scope.UpdateBuilder(&builder); |
901 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
902 | if (!scope.ok()) return; |
903 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
904 | this->operation = Operation(ret); |
905 | this->handle = Output(ret, 0); |
906 | } |
907 | |
908 | ExperimentalAutoShardDataset::ExperimentalAutoShardDataset(const |
909 | ::tensorflow::Scope& |
910 | scope, |
911 | ::tensorflow::Input |
912 | input_dataset, |
913 | ::tensorflow::Input |
914 | num_workers, |
915 | ::tensorflow::Input |
916 | index, const |
917 | DataTypeSlice& |
918 | output_types, const |
919 | gtl::ArraySlice<PartialTensorShape>& |
920 | output_shapes) |
921 | : ExperimentalAutoShardDataset(scope, input_dataset, num_workers, index, output_types, output_shapes, ExperimentalAutoShardDataset::Attrs()) {} |
922 | |
923 | ExperimentalBytesProducedStatsDataset::ExperimentalBytesProducedStatsDataset(const |
924 | ::tensorflow::Scope& |
925 | scope, |
926 | ::tensorflow::Input |
927 | input_dataset, |
928 | ::tensorflow::Input |
929 | tag, |
930 | const |
931 | DataTypeSlice& |
932 | output_types, |
933 | const |
934 | gtl::ArraySlice<PartialTensorShape>& |
935 | output_shapes) { |
936 | if (!scope.ok()) return; |
937 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
938 | if (!scope.ok()) return; |
939 | auto _tag = ::tensorflow::ops::AsNodeOut(scope, tag); |
940 | if (!scope.ok()) return; |
941 | ::tensorflow::Node* ret; |
942 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalBytesProducedStatsDataset" ); |
943 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalBytesProducedStatsDataset" ) |
944 | .Input(_input_dataset) |
945 | .Input(_tag) |
946 | .Attr("output_types" , output_types) |
947 | .Attr("output_shapes" , output_shapes) |
948 | ; |
949 | scope.UpdateBuilder(&builder); |
950 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
951 | if (!scope.ok()) return; |
952 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
953 | this->operation = Operation(ret); |
954 | this->handle = Output(ret, 0); |
955 | } |
956 | |
957 | ExperimentalCSVDataset::ExperimentalCSVDataset(const ::tensorflow::Scope& |
958 | scope, ::tensorflow::Input |
959 | filenames, ::tensorflow::Input |
960 | compression_type, |
961 | ::tensorflow::Input buffer_size, |
962 | ::tensorflow::Input , |
963 | ::tensorflow::Input field_delim, |
964 | ::tensorflow::Input |
965 | use_quote_delim, |
966 | ::tensorflow::Input na_value, |
967 | ::tensorflow::Input select_cols, |
968 | ::tensorflow::InputList |
969 | record_defaults, const |
970 | gtl::ArraySlice<PartialTensorShape>& |
971 | output_shapes) { |
972 | if (!scope.ok()) return; |
973 | auto _filenames = ::tensorflow::ops::AsNodeOut(scope, filenames); |
974 | if (!scope.ok()) return; |
975 | auto _compression_type = ::tensorflow::ops::AsNodeOut(scope, compression_type); |
976 | if (!scope.ok()) return; |
977 | auto _buffer_size = ::tensorflow::ops::AsNodeOut(scope, buffer_size); |
978 | if (!scope.ok()) return; |
979 | auto = ::tensorflow::ops::AsNodeOut(scope, header); |
980 | if (!scope.ok()) return; |
981 | auto _field_delim = ::tensorflow::ops::AsNodeOut(scope, field_delim); |
982 | if (!scope.ok()) return; |
983 | auto _use_quote_delim = ::tensorflow::ops::AsNodeOut(scope, use_quote_delim); |
984 | if (!scope.ok()) return; |
985 | auto _na_value = ::tensorflow::ops::AsNodeOut(scope, na_value); |
986 | if (!scope.ok()) return; |
987 | auto _select_cols = ::tensorflow::ops::AsNodeOut(scope, select_cols); |
988 | if (!scope.ok()) return; |
989 | auto _record_defaults = ::tensorflow::ops::AsNodeOutList(scope, record_defaults); |
990 | if (!scope.ok()) return; |
991 | ::tensorflow::Node* ret; |
992 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalCSVDataset" ); |
993 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalCSVDataset" ) |
994 | .Input(_filenames) |
995 | .Input(_compression_type) |
996 | .Input(_buffer_size) |
997 | .Input(_header) |
998 | .Input(_field_delim) |
999 | .Input(_use_quote_delim) |
1000 | .Input(_na_value) |
1001 | .Input(_select_cols) |
1002 | .Input(_record_defaults) |
1003 | .Attr("output_shapes" , output_shapes) |
1004 | ; |
1005 | scope.UpdateBuilder(&builder); |
1006 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1007 | if (!scope.ok()) return; |
1008 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1009 | this->operation = Operation(ret); |
1010 | this->handle = Output(ret, 0); |
1011 | } |
1012 | |
1013 | ExperimentalChooseFastestDataset::ExperimentalChooseFastestDataset(const |
1014 | ::tensorflow::Scope& |
1015 | scope, |
1016 | ::tensorflow::InputList |
1017 | input_datasets, |
1018 | int64 |
1019 | num_experiments, |
1020 | const |
1021 | DataTypeSlice& |
1022 | output_types, |
1023 | const |
1024 | gtl::ArraySlice<PartialTensorShape>& |
1025 | output_shapes) { |
1026 | if (!scope.ok()) return; |
1027 | auto _input_datasets = ::tensorflow::ops::AsNodeOutList(scope, input_datasets); |
1028 | if (!scope.ok()) return; |
1029 | ::tensorflow::Node* ret; |
1030 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalChooseFastestDataset" ); |
1031 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalChooseFastestDataset" ) |
1032 | .Input(_input_datasets) |
1033 | .Attr("num_experiments" , num_experiments) |
1034 | .Attr("output_types" , output_types) |
1035 | .Attr("output_shapes" , output_shapes) |
1036 | ; |
1037 | scope.UpdateBuilder(&builder); |
1038 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1039 | if (!scope.ok()) return; |
1040 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1041 | this->operation = Operation(ret); |
1042 | this->handle = Output(ret, 0); |
1043 | } |
1044 | |
1045 | ExperimentalDatasetCardinality::ExperimentalDatasetCardinality(const |
1046 | ::tensorflow::Scope& |
1047 | scope, |
1048 | ::tensorflow::Input |
1049 | input_dataset) { |
1050 | if (!scope.ok()) return; |
1051 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1052 | if (!scope.ok()) return; |
1053 | ::tensorflow::Node* ret; |
1054 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalDatasetCardinality" ); |
1055 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalDatasetCardinality" ) |
1056 | .Input(_input_dataset) |
1057 | ; |
1058 | scope.UpdateBuilder(&builder); |
1059 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1060 | if (!scope.ok()) return; |
1061 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1062 | this->operation = Operation(ret); |
1063 | this->cardinality = Output(ret, 0); |
1064 | } |
1065 | |
1066 | ExperimentalDatasetToTFRecord::ExperimentalDatasetToTFRecord(const |
1067 | ::tensorflow::Scope& |
1068 | scope, |
1069 | ::tensorflow::Input |
1070 | input_dataset, |
1071 | ::tensorflow::Input |
1072 | filename, |
1073 | ::tensorflow::Input |
1074 | compression_type) { |
1075 | if (!scope.ok()) return; |
1076 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1077 | if (!scope.ok()) return; |
1078 | auto _filename = ::tensorflow::ops::AsNodeOut(scope, filename); |
1079 | if (!scope.ok()) return; |
1080 | auto _compression_type = ::tensorflow::ops::AsNodeOut(scope, compression_type); |
1081 | if (!scope.ok()) return; |
1082 | ::tensorflow::Node* ret; |
1083 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalDatasetToTFRecord" ); |
1084 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalDatasetToTFRecord" ) |
1085 | .Input(_input_dataset) |
1086 | .Input(_filename) |
1087 | .Input(_compression_type) |
1088 | ; |
1089 | scope.UpdateBuilder(&builder); |
1090 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1091 | if (!scope.ok()) return; |
1092 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1093 | this->operation = Operation(ret); |
1094 | return; |
1095 | } |
1096 | |
1097 | ExperimentalDenseToSparseBatchDataset::ExperimentalDenseToSparseBatchDataset(const |
1098 | ::tensorflow::Scope& |
1099 | scope, |
1100 | ::tensorflow::Input |
1101 | input_dataset, |
1102 | ::tensorflow::Input |
1103 | batch_size, |
1104 | ::tensorflow::Input |
1105 | row_shape, |
1106 | const |
1107 | DataTypeSlice& |
1108 | output_types, |
1109 | const |
1110 | gtl::ArraySlice<PartialTensorShape>& |
1111 | output_shapes) { |
1112 | if (!scope.ok()) return; |
1113 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1114 | if (!scope.ok()) return; |
1115 | auto _batch_size = ::tensorflow::ops::AsNodeOut(scope, batch_size); |
1116 | if (!scope.ok()) return; |
1117 | auto _row_shape = ::tensorflow::ops::AsNodeOut(scope, row_shape); |
1118 | if (!scope.ok()) return; |
1119 | ::tensorflow::Node* ret; |
1120 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalDenseToSparseBatchDataset" ); |
1121 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalDenseToSparseBatchDataset" ) |
1122 | .Input(_input_dataset) |
1123 | .Input(_batch_size) |
1124 | .Input(_row_shape) |
1125 | .Attr("output_types" , output_types) |
1126 | .Attr("output_shapes" , output_shapes) |
1127 | ; |
1128 | scope.UpdateBuilder(&builder); |
1129 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1130 | if (!scope.ok()) return; |
1131 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1132 | this->operation = Operation(ret); |
1133 | this->handle = Output(ret, 0); |
1134 | } |
1135 | |
1136 | ExperimentalDirectedInterleaveDataset::ExperimentalDirectedInterleaveDataset(const |
1137 | ::tensorflow::Scope& |
1138 | scope, |
1139 | ::tensorflow::Input |
1140 | selector_input_dataset, |
1141 | ::tensorflow::InputList |
1142 | data_input_datasets, |
1143 | const |
1144 | DataTypeSlice& |
1145 | output_types, |
1146 | const |
1147 | gtl::ArraySlice<PartialTensorShape>& |
1148 | output_shapes) { |
1149 | if (!scope.ok()) return; |
1150 | auto _selector_input_dataset = ::tensorflow::ops::AsNodeOut(scope, selector_input_dataset); |
1151 | if (!scope.ok()) return; |
1152 | auto _data_input_datasets = ::tensorflow::ops::AsNodeOutList(scope, data_input_datasets); |
1153 | if (!scope.ok()) return; |
1154 | ::tensorflow::Node* ret; |
1155 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalDirectedInterleaveDataset" ); |
1156 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalDirectedInterleaveDataset" ) |
1157 | .Input(_selector_input_dataset) |
1158 | .Input(_data_input_datasets) |
1159 | .Attr("output_types" , output_types) |
1160 | .Attr("output_shapes" , output_shapes) |
1161 | ; |
1162 | scope.UpdateBuilder(&builder); |
1163 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1164 | if (!scope.ok()) return; |
1165 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1166 | this->operation = Operation(ret); |
1167 | this->handle = Output(ret, 0); |
1168 | } |
1169 | |
1170 | ExperimentalGroupByReducerDataset::ExperimentalGroupByReducerDataset(const |
1171 | ::tensorflow::Scope& |
1172 | scope, |
1173 | ::tensorflow::Input |
1174 | input_dataset, |
1175 | ::tensorflow::InputList |
1176 | key_func_other_arguments, |
1177 | ::tensorflow::InputList |
1178 | init_func_other_arguments, |
1179 | ::tensorflow::InputList |
1180 | reduce_func_other_arguments, |
1181 | ::tensorflow::InputList |
1182 | finalize_func_other_arguments, |
1183 | const |
1184 | NameAttrList& |
1185 | key_func, |
1186 | const |
1187 | NameAttrList& |
1188 | init_func, |
1189 | const |
1190 | NameAttrList& |
1191 | reduce_func, |
1192 | const |
1193 | NameAttrList& |
1194 | finalize_func, |
1195 | const |
1196 | DataTypeSlice& |
1197 | output_types, |
1198 | const |
1199 | gtl::ArraySlice<PartialTensorShape>& |
1200 | output_shapes) { |
1201 | if (!scope.ok()) return; |
1202 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1203 | if (!scope.ok()) return; |
1204 | auto _key_func_other_arguments = ::tensorflow::ops::AsNodeOutList(scope, key_func_other_arguments); |
1205 | if (!scope.ok()) return; |
1206 | auto _init_func_other_arguments = ::tensorflow::ops::AsNodeOutList(scope, init_func_other_arguments); |
1207 | if (!scope.ok()) return; |
1208 | auto _reduce_func_other_arguments = ::tensorflow::ops::AsNodeOutList(scope, reduce_func_other_arguments); |
1209 | if (!scope.ok()) return; |
1210 | auto _finalize_func_other_arguments = ::tensorflow::ops::AsNodeOutList(scope, finalize_func_other_arguments); |
1211 | if (!scope.ok()) return; |
1212 | ::tensorflow::Node* ret; |
1213 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalGroupByReducerDataset" ); |
1214 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalGroupByReducerDataset" ) |
1215 | .Input(_input_dataset) |
1216 | .Input(_key_func_other_arguments) |
1217 | .Input(_init_func_other_arguments) |
1218 | .Input(_reduce_func_other_arguments) |
1219 | .Input(_finalize_func_other_arguments) |
1220 | .Attr("key_func" , key_func) |
1221 | .Attr("init_func" , init_func) |
1222 | .Attr("reduce_func" , reduce_func) |
1223 | .Attr("finalize_func" , finalize_func) |
1224 | .Attr("output_types" , output_types) |
1225 | .Attr("output_shapes" , output_shapes) |
1226 | ; |
1227 | scope.UpdateBuilder(&builder); |
1228 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1229 | if (!scope.ok()) return; |
1230 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1231 | this->operation = Operation(ret); |
1232 | this->handle = Output(ret, 0); |
1233 | } |
1234 | |
1235 | ExperimentalGroupByWindowDataset::ExperimentalGroupByWindowDataset(const |
1236 | ::tensorflow::Scope& |
1237 | scope, |
1238 | ::tensorflow::Input |
1239 | input_dataset, |
1240 | ::tensorflow::InputList |
1241 | key_func_other_arguments, |
1242 | ::tensorflow::InputList |
1243 | reduce_func_other_arguments, |
1244 | ::tensorflow::InputList |
1245 | window_size_func_other_arguments, |
1246 | const |
1247 | NameAttrList& |
1248 | key_func, |
1249 | const |
1250 | NameAttrList& |
1251 | reduce_func, |
1252 | const |
1253 | NameAttrList& |
1254 | window_size_func, |
1255 | const |
1256 | DataTypeSlice& |
1257 | output_types, |
1258 | const |
1259 | gtl::ArraySlice<PartialTensorShape>& |
1260 | output_shapes) { |
1261 | if (!scope.ok()) return; |
1262 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1263 | if (!scope.ok()) return; |
1264 | auto _key_func_other_arguments = ::tensorflow::ops::AsNodeOutList(scope, key_func_other_arguments); |
1265 | if (!scope.ok()) return; |
1266 | auto _reduce_func_other_arguments = ::tensorflow::ops::AsNodeOutList(scope, reduce_func_other_arguments); |
1267 | if (!scope.ok()) return; |
1268 | auto _window_size_func_other_arguments = ::tensorflow::ops::AsNodeOutList(scope, window_size_func_other_arguments); |
1269 | if (!scope.ok()) return; |
1270 | ::tensorflow::Node* ret; |
1271 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalGroupByWindowDataset" ); |
1272 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalGroupByWindowDataset" ) |
1273 | .Input(_input_dataset) |
1274 | .Input(_key_func_other_arguments) |
1275 | .Input(_reduce_func_other_arguments) |
1276 | .Input(_window_size_func_other_arguments) |
1277 | .Attr("key_func" , key_func) |
1278 | .Attr("reduce_func" , reduce_func) |
1279 | .Attr("window_size_func" , window_size_func) |
1280 | .Attr("output_types" , output_types) |
1281 | .Attr("output_shapes" , output_shapes) |
1282 | ; |
1283 | scope.UpdateBuilder(&builder); |
1284 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1285 | if (!scope.ok()) return; |
1286 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1287 | this->operation = Operation(ret); |
1288 | this->handle = Output(ret, 0); |
1289 | } |
1290 | |
1291 | ExperimentalIgnoreErrorsDataset::ExperimentalIgnoreErrorsDataset(const |
1292 | ::tensorflow::Scope& |
1293 | scope, |
1294 | ::tensorflow::Input |
1295 | input_dataset, |
1296 | const |
1297 | DataTypeSlice& |
1298 | output_types, |
1299 | const |
1300 | gtl::ArraySlice<PartialTensorShape>& |
1301 | output_shapes, |
1302 | const |
1303 | ExperimentalIgnoreErrorsDataset::Attrs& |
1304 | attrs) { |
1305 | if (!scope.ok()) return; |
1306 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1307 | if (!scope.ok()) return; |
1308 | ::tensorflow::Node* ret; |
1309 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalIgnoreErrorsDataset" ); |
1310 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalIgnoreErrorsDataset" ) |
1311 | .Input(_input_dataset) |
1312 | .Attr("output_types" , output_types) |
1313 | .Attr("output_shapes" , output_shapes) |
1314 | .Attr("log_warning" , attrs.log_warning_) |
1315 | ; |
1316 | scope.UpdateBuilder(&builder); |
1317 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1318 | if (!scope.ok()) return; |
1319 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1320 | this->operation = Operation(ret); |
1321 | this->handle = Output(ret, 0); |
1322 | } |
1323 | |
1324 | ExperimentalIgnoreErrorsDataset::ExperimentalIgnoreErrorsDataset(const |
1325 | ::tensorflow::Scope& |
1326 | scope, |
1327 | ::tensorflow::Input |
1328 | input_dataset, |
1329 | const |
1330 | DataTypeSlice& |
1331 | output_types, |
1332 | const |
1333 | gtl::ArraySlice<PartialTensorShape>& |
1334 | output_shapes) |
1335 | : ExperimentalIgnoreErrorsDataset(scope, input_dataset, output_types, output_shapes, ExperimentalIgnoreErrorsDataset::Attrs()) {} |
1336 | |
1337 | ExperimentalIteratorGetDevice::ExperimentalIteratorGetDevice(const |
1338 | ::tensorflow::Scope& |
1339 | scope, |
1340 | ::tensorflow::Input |
1341 | resource) { |
1342 | if (!scope.ok()) return; |
1343 | auto _resource = ::tensorflow::ops::AsNodeOut(scope, resource); |
1344 | if (!scope.ok()) return; |
1345 | ::tensorflow::Node* ret; |
1346 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalIteratorGetDevice" ); |
1347 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalIteratorGetDevice" ) |
1348 | .Input(_resource) |
1349 | ; |
1350 | scope.UpdateBuilder(&builder); |
1351 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1352 | if (!scope.ok()) return; |
1353 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1354 | this->operation = Operation(ret); |
1355 | this->device = Output(ret, 0); |
1356 | } |
1357 | |
1358 | ExperimentalLMDBDataset::ExperimentalLMDBDataset(const ::tensorflow::Scope& |
1359 | scope, ::tensorflow::Input |
1360 | filenames, const |
1361 | DataTypeSlice& output_types, |
1362 | const |
1363 | gtl::ArraySlice<PartialTensorShape>& |
1364 | output_shapes) { |
1365 | if (!scope.ok()) return; |
1366 | auto _filenames = ::tensorflow::ops::AsNodeOut(scope, filenames); |
1367 | if (!scope.ok()) return; |
1368 | ::tensorflow::Node* ret; |
1369 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalLMDBDataset" ); |
1370 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalLMDBDataset" ) |
1371 | .Input(_filenames) |
1372 | .Attr("output_types" , output_types) |
1373 | .Attr("output_shapes" , output_shapes) |
1374 | ; |
1375 | scope.UpdateBuilder(&builder); |
1376 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1377 | if (!scope.ok()) return; |
1378 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1379 | this->operation = Operation(ret); |
1380 | this->handle = Output(ret, 0); |
1381 | } |
1382 | |
1383 | ExperimentalLatencyStatsDataset::ExperimentalLatencyStatsDataset(const |
1384 | ::tensorflow::Scope& |
1385 | scope, |
1386 | ::tensorflow::Input |
1387 | input_dataset, |
1388 | ::tensorflow::Input |
1389 | tag, const |
1390 | DataTypeSlice& |
1391 | output_types, |
1392 | const |
1393 | gtl::ArraySlice<PartialTensorShape>& |
1394 | output_shapes) { |
1395 | if (!scope.ok()) return; |
1396 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1397 | if (!scope.ok()) return; |
1398 | auto _tag = ::tensorflow::ops::AsNodeOut(scope, tag); |
1399 | if (!scope.ok()) return; |
1400 | ::tensorflow::Node* ret; |
1401 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalLatencyStatsDataset" ); |
1402 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalLatencyStatsDataset" ) |
1403 | .Input(_input_dataset) |
1404 | .Input(_tag) |
1405 | .Attr("output_types" , output_types) |
1406 | .Attr("output_shapes" , output_shapes) |
1407 | ; |
1408 | scope.UpdateBuilder(&builder); |
1409 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1410 | if (!scope.ok()) return; |
1411 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1412 | this->operation = Operation(ret); |
1413 | this->handle = Output(ret, 0); |
1414 | } |
1415 | |
1416 | ExperimentalMapAndBatchDataset::ExperimentalMapAndBatchDataset(const |
1417 | ::tensorflow::Scope& |
1418 | scope, |
1419 | ::tensorflow::Input |
1420 | input_dataset, |
1421 | ::tensorflow::InputList |
1422 | other_arguments, |
1423 | ::tensorflow::Input |
1424 | batch_size, |
1425 | ::tensorflow::Input |
1426 | num_parallel_calls, |
1427 | ::tensorflow::Input |
1428 | drop_remainder, |
1429 | const |
1430 | NameAttrList& f, |
1431 | const |
1432 | DataTypeSlice& |
1433 | output_types, |
1434 | const |
1435 | gtl::ArraySlice<PartialTensorShape>& |
1436 | output_shapes, |
1437 | const |
1438 | ExperimentalMapAndBatchDataset::Attrs& |
1439 | attrs) { |
1440 | if (!scope.ok()) return; |
1441 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1442 | if (!scope.ok()) return; |
1443 | auto _other_arguments = ::tensorflow::ops::AsNodeOutList(scope, other_arguments); |
1444 | if (!scope.ok()) return; |
1445 | auto _batch_size = ::tensorflow::ops::AsNodeOut(scope, batch_size); |
1446 | if (!scope.ok()) return; |
1447 | auto _num_parallel_calls = ::tensorflow::ops::AsNodeOut(scope, num_parallel_calls); |
1448 | if (!scope.ok()) return; |
1449 | auto _drop_remainder = ::tensorflow::ops::AsNodeOut(scope, drop_remainder); |
1450 | if (!scope.ok()) return; |
1451 | ::tensorflow::Node* ret; |
1452 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalMapAndBatchDataset" ); |
1453 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalMapAndBatchDataset" ) |
1454 | .Input(_input_dataset) |
1455 | .Input(_other_arguments) |
1456 | .Input(_batch_size) |
1457 | .Input(_num_parallel_calls) |
1458 | .Input(_drop_remainder) |
1459 | .Attr("f" , f) |
1460 | .Attr("output_types" , output_types) |
1461 | .Attr("output_shapes" , output_shapes) |
1462 | .Attr("preserve_cardinality" , attrs.preserve_cardinality_) |
1463 | ; |
1464 | scope.UpdateBuilder(&builder); |
1465 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1466 | if (!scope.ok()) return; |
1467 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1468 | this->operation = Operation(ret); |
1469 | this->handle = Output(ret, 0); |
1470 | } |
1471 | |
1472 | ExperimentalMapAndBatchDataset::ExperimentalMapAndBatchDataset(const |
1473 | ::tensorflow::Scope& |
1474 | scope, |
1475 | ::tensorflow::Input |
1476 | input_dataset, |
1477 | ::tensorflow::InputList |
1478 | other_arguments, |
1479 | ::tensorflow::Input |
1480 | batch_size, |
1481 | ::tensorflow::Input |
1482 | num_parallel_calls, |
1483 | ::tensorflow::Input |
1484 | drop_remainder, |
1485 | const |
1486 | NameAttrList& f, |
1487 | const |
1488 | DataTypeSlice& |
1489 | output_types, |
1490 | const |
1491 | gtl::ArraySlice<PartialTensorShape>& |
1492 | output_shapes) |
1493 | : ExperimentalMapAndBatchDataset(scope, input_dataset, other_arguments, batch_size, num_parallel_calls, drop_remainder, f, output_types, output_shapes, ExperimentalMapAndBatchDataset::Attrs()) {} |
1494 | |
1495 | ExperimentalMapDataset::ExperimentalMapDataset(const ::tensorflow::Scope& |
1496 | scope, ::tensorflow::Input |
1497 | input_dataset, |
1498 | ::tensorflow::InputList |
1499 | other_arguments, const |
1500 | NameAttrList& f, const |
1501 | DataTypeSlice& output_types, |
1502 | const |
1503 | gtl::ArraySlice<PartialTensorShape>& |
1504 | output_shapes, const |
1505 | ExperimentalMapDataset::Attrs& |
1506 | attrs) { |
1507 | if (!scope.ok()) return; |
1508 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1509 | if (!scope.ok()) return; |
1510 | auto _other_arguments = ::tensorflow::ops::AsNodeOutList(scope, other_arguments); |
1511 | if (!scope.ok()) return; |
1512 | ::tensorflow::Node* ret; |
1513 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalMapDataset" ); |
1514 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalMapDataset" ) |
1515 | .Input(_input_dataset) |
1516 | .Input(_other_arguments) |
1517 | .Attr("f" , f) |
1518 | .Attr("output_types" , output_types) |
1519 | .Attr("output_shapes" , output_shapes) |
1520 | .Attr("use_inter_op_parallelism" , attrs.use_inter_op_parallelism_) |
1521 | .Attr("preserve_cardinality" , attrs.preserve_cardinality_) |
1522 | ; |
1523 | scope.UpdateBuilder(&builder); |
1524 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1525 | if (!scope.ok()) return; |
1526 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1527 | this->operation = Operation(ret); |
1528 | this->handle = Output(ret, 0); |
1529 | } |
1530 | |
1531 | ExperimentalMapDataset::ExperimentalMapDataset(const ::tensorflow::Scope& |
1532 | scope, ::tensorflow::Input |
1533 | input_dataset, |
1534 | ::tensorflow::InputList |
1535 | other_arguments, const |
1536 | NameAttrList& f, const |
1537 | DataTypeSlice& output_types, |
1538 | const |
1539 | gtl::ArraySlice<PartialTensorShape>& |
1540 | output_shapes) |
1541 | : ExperimentalMapDataset(scope, input_dataset, other_arguments, f, output_types, output_shapes, ExperimentalMapDataset::Attrs()) {} |
1542 | |
1543 | ExperimentalMatchingFilesDataset::ExperimentalMatchingFilesDataset(const |
1544 | ::tensorflow::Scope& |
1545 | scope, |
1546 | ::tensorflow::Input |
1547 | patterns) { |
1548 | if (!scope.ok()) return; |
1549 | auto _patterns = ::tensorflow::ops::AsNodeOut(scope, patterns); |
1550 | if (!scope.ok()) return; |
1551 | ::tensorflow::Node* ret; |
1552 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalMatchingFilesDataset" ); |
1553 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalMatchingFilesDataset" ) |
1554 | .Input(_patterns) |
1555 | ; |
1556 | scope.UpdateBuilder(&builder); |
1557 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1558 | if (!scope.ok()) return; |
1559 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1560 | this->operation = Operation(ret); |
1561 | this->handle = Output(ret, 0); |
1562 | } |
1563 | |
1564 | ExperimentalMaxIntraOpParallelismDataset::ExperimentalMaxIntraOpParallelismDataset(const ::tensorflow::Scope& scope, ::tensorflow::Input input_dataset, ::tensorflow::Input max_intra_op_parallelism, const DataTypeSlice& output_types, const gtl::ArraySlice<PartialTensorShape>& |
1565 | output_shapes) { |
1566 | if (!scope.ok()) return; |
1567 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1568 | if (!scope.ok()) return; |
1569 | auto _max_intra_op_parallelism = ::tensorflow::ops::AsNodeOut(scope, max_intra_op_parallelism); |
1570 | if (!scope.ok()) return; |
1571 | ::tensorflow::Node* ret; |
1572 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalMaxIntraOpParallelismDataset" ); |
1573 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalMaxIntraOpParallelismDataset" ) |
1574 | .Input(_input_dataset) |
1575 | .Input(_max_intra_op_parallelism) |
1576 | .Attr("output_types" , output_types) |
1577 | .Attr("output_shapes" , output_shapes) |
1578 | ; |
1579 | scope.UpdateBuilder(&builder); |
1580 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1581 | if (!scope.ok()) return; |
1582 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1583 | this->operation = Operation(ret); |
1584 | this->handle = Output(ret, 0); |
1585 | } |
1586 | |
1587 | ExperimentalNonSerializableDataset::ExperimentalNonSerializableDataset(const |
1588 | ::tensorflow::Scope& |
1589 | scope, |
1590 | ::tensorflow::Input |
1591 | input_dataset, |
1592 | const |
1593 | DataTypeSlice& |
1594 | output_types, |
1595 | const |
1596 | gtl::ArraySlice<PartialTensorShape>& |
1597 | output_shapes) { |
1598 | if (!scope.ok()) return; |
1599 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1600 | if (!scope.ok()) return; |
1601 | ::tensorflow::Node* ret; |
1602 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalNonSerializableDataset" ); |
1603 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalNonSerializableDataset" ) |
1604 | .Input(_input_dataset) |
1605 | .Attr("output_types" , output_types) |
1606 | .Attr("output_shapes" , output_shapes) |
1607 | ; |
1608 | scope.UpdateBuilder(&builder); |
1609 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1610 | if (!scope.ok()) return; |
1611 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1612 | this->operation = Operation(ret); |
1613 | this->handle = Output(ret, 0); |
1614 | } |
1615 | |
1616 | ExperimentalParallelInterleaveDataset::ExperimentalParallelInterleaveDataset(const |
1617 | ::tensorflow::Scope& |
1618 | scope, |
1619 | ::tensorflow::Input |
1620 | input_dataset, |
1621 | ::tensorflow::InputList |
1622 | other_arguments, |
1623 | ::tensorflow::Input |
1624 | cycle_length, |
1625 | ::tensorflow::Input |
1626 | block_length, |
1627 | ::tensorflow::Input |
1628 | sloppy, |
1629 | ::tensorflow::Input |
1630 | buffer_output_elements, |
1631 | ::tensorflow::Input |
1632 | prefetch_input_elements, |
1633 | const |
1634 | NameAttrList& |
1635 | f, |
1636 | const |
1637 | DataTypeSlice& |
1638 | output_types, |
1639 | const |
1640 | gtl::ArraySlice<PartialTensorShape>& |
1641 | output_shapes) { |
1642 | if (!scope.ok()) return; |
1643 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1644 | if (!scope.ok()) return; |
1645 | auto _other_arguments = ::tensorflow::ops::AsNodeOutList(scope, other_arguments); |
1646 | if (!scope.ok()) return; |
1647 | auto _cycle_length = ::tensorflow::ops::AsNodeOut(scope, cycle_length); |
1648 | if (!scope.ok()) return; |
1649 | auto _block_length = ::tensorflow::ops::AsNodeOut(scope, block_length); |
1650 | if (!scope.ok()) return; |
1651 | auto _sloppy = ::tensorflow::ops::AsNodeOut(scope, sloppy); |
1652 | if (!scope.ok()) return; |
1653 | auto _buffer_output_elements = ::tensorflow::ops::AsNodeOut(scope, buffer_output_elements); |
1654 | if (!scope.ok()) return; |
1655 | auto _prefetch_input_elements = ::tensorflow::ops::AsNodeOut(scope, prefetch_input_elements); |
1656 | if (!scope.ok()) return; |
1657 | ::tensorflow::Node* ret; |
1658 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalParallelInterleaveDataset" ); |
1659 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalParallelInterleaveDataset" ) |
1660 | .Input(_input_dataset) |
1661 | .Input(_other_arguments) |
1662 | .Input(_cycle_length) |
1663 | .Input(_block_length) |
1664 | .Input(_sloppy) |
1665 | .Input(_buffer_output_elements) |
1666 | .Input(_prefetch_input_elements) |
1667 | .Attr("f" , f) |
1668 | .Attr("output_types" , output_types) |
1669 | .Attr("output_shapes" , output_shapes) |
1670 | ; |
1671 | scope.UpdateBuilder(&builder); |
1672 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1673 | if (!scope.ok()) return; |
1674 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1675 | this->operation = Operation(ret); |
1676 | this->handle = Output(ret, 0); |
1677 | } |
1678 | |
1679 | ExperimentalParseExampleDataset::ExperimentalParseExampleDataset(const |
1680 | ::tensorflow::Scope& |
1681 | scope, |
1682 | ::tensorflow::Input |
1683 | input_dataset, |
1684 | ::tensorflow::Input |
1685 | num_parallel_calls, |
1686 | ::tensorflow::InputList |
1687 | dense_defaults, |
1688 | const |
1689 | gtl::ArraySlice<::tensorflow::tstring>& |
1690 | sparse_keys, |
1691 | const |
1692 | gtl::ArraySlice<::tensorflow::tstring>& |
1693 | dense_keys, |
1694 | const |
1695 | DataTypeSlice& |
1696 | sparse_types, |
1697 | const |
1698 | gtl::ArraySlice<PartialTensorShape>& |
1699 | dense_shapes, |
1700 | const |
1701 | DataTypeSlice& |
1702 | output_types, |
1703 | const |
1704 | gtl::ArraySlice<PartialTensorShape>& |
1705 | output_shapes, |
1706 | const |
1707 | ExperimentalParseExampleDataset::Attrs& |
1708 | attrs) { |
1709 | if (!scope.ok()) return; |
1710 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1711 | if (!scope.ok()) return; |
1712 | auto _num_parallel_calls = ::tensorflow::ops::AsNodeOut(scope, num_parallel_calls); |
1713 | if (!scope.ok()) return; |
1714 | auto _dense_defaults = ::tensorflow::ops::AsNodeOutList(scope, dense_defaults); |
1715 | if (!scope.ok()) return; |
1716 | ::tensorflow::Node* ret; |
1717 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalParseExampleDataset" ); |
1718 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalParseExampleDataset" ) |
1719 | .Input(_input_dataset) |
1720 | .Input(_num_parallel_calls) |
1721 | .Input(_dense_defaults) |
1722 | .Attr("sparse_keys" , sparse_keys) |
1723 | .Attr("dense_keys" , dense_keys) |
1724 | .Attr("sparse_types" , sparse_types) |
1725 | .Attr("dense_shapes" , dense_shapes) |
1726 | .Attr("output_types" , output_types) |
1727 | .Attr("output_shapes" , output_shapes) |
1728 | .Attr("sloppy" , attrs.sloppy_) |
1729 | ; |
1730 | scope.UpdateBuilder(&builder); |
1731 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1732 | if (!scope.ok()) return; |
1733 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1734 | this->operation = Operation(ret); |
1735 | this->handle = Output(ret, 0); |
1736 | } |
1737 | |
1738 | ExperimentalParseExampleDataset::ExperimentalParseExampleDataset(const |
1739 | ::tensorflow::Scope& |
1740 | scope, |
1741 | ::tensorflow::Input |
1742 | input_dataset, |
1743 | ::tensorflow::Input |
1744 | num_parallel_calls, |
1745 | ::tensorflow::InputList |
1746 | dense_defaults, |
1747 | const |
1748 | gtl::ArraySlice<::tensorflow::tstring>& |
1749 | sparse_keys, |
1750 | const |
1751 | gtl::ArraySlice<::tensorflow::tstring>& |
1752 | dense_keys, |
1753 | const |
1754 | DataTypeSlice& |
1755 | sparse_types, |
1756 | const |
1757 | gtl::ArraySlice<PartialTensorShape>& |
1758 | dense_shapes, |
1759 | const |
1760 | DataTypeSlice& |
1761 | output_types, |
1762 | const |
1763 | gtl::ArraySlice<PartialTensorShape>& |
1764 | output_shapes) |
1765 | : ExperimentalParseExampleDataset(scope, input_dataset, num_parallel_calls, dense_defaults, sparse_keys, dense_keys, sparse_types, dense_shapes, output_types, output_shapes, ExperimentalParseExampleDataset::Attrs()) {} |
1766 | |
1767 | ExperimentalPrivateThreadPoolDataset::ExperimentalPrivateThreadPoolDataset(const |
1768 | ::tensorflow::Scope& |
1769 | scope, |
1770 | ::tensorflow::Input |
1771 | input_dataset, |
1772 | ::tensorflow::Input |
1773 | num_threads, |
1774 | const |
1775 | DataTypeSlice& |
1776 | output_types, |
1777 | const |
1778 | gtl::ArraySlice<PartialTensorShape>& |
1779 | output_shapes) { |
1780 | if (!scope.ok()) return; |
1781 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1782 | if (!scope.ok()) return; |
1783 | auto _num_threads = ::tensorflow::ops::AsNodeOut(scope, num_threads); |
1784 | if (!scope.ok()) return; |
1785 | ::tensorflow::Node* ret; |
1786 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalPrivateThreadPoolDataset" ); |
1787 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalPrivateThreadPoolDataset" ) |
1788 | .Input(_input_dataset) |
1789 | .Input(_num_threads) |
1790 | .Attr("output_types" , output_types) |
1791 | .Attr("output_shapes" , output_shapes) |
1792 | ; |
1793 | scope.UpdateBuilder(&builder); |
1794 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1795 | if (!scope.ok()) return; |
1796 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1797 | this->operation = Operation(ret); |
1798 | this->handle = Output(ret, 0); |
1799 | } |
1800 | |
1801 | ExperimentalRandomDataset::ExperimentalRandomDataset(const ::tensorflow::Scope& |
1802 | scope, ::tensorflow::Input |
1803 | seed, ::tensorflow::Input |
1804 | seed2, const |
1805 | DataTypeSlice& |
1806 | output_types, const |
1807 | gtl::ArraySlice<PartialTensorShape>& |
1808 | output_shapes) { |
1809 | if (!scope.ok()) return; |
1810 | auto _seed = ::tensorflow::ops::AsNodeOut(scope, seed); |
1811 | if (!scope.ok()) return; |
1812 | auto _seed2 = ::tensorflow::ops::AsNodeOut(scope, seed2); |
1813 | if (!scope.ok()) return; |
1814 | ::tensorflow::Node* ret; |
1815 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalRandomDataset" ); |
1816 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalRandomDataset" ) |
1817 | .Input(_seed) |
1818 | .Input(_seed2) |
1819 | .Attr("output_types" , output_types) |
1820 | .Attr("output_shapes" , output_shapes) |
1821 | ; |
1822 | scope.UpdateBuilder(&builder); |
1823 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1824 | if (!scope.ok()) return; |
1825 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1826 | this->operation = Operation(ret); |
1827 | this->handle = Output(ret, 0); |
1828 | } |
1829 | |
1830 | ExperimentalRebatchDataset::ExperimentalRebatchDataset(const |
1831 | ::tensorflow::Scope& |
1832 | scope, |
1833 | ::tensorflow::Input |
1834 | input_dataset, |
1835 | ::tensorflow::Input |
1836 | num_replicas, const |
1837 | DataTypeSlice& |
1838 | output_types, const |
1839 | gtl::ArraySlice<PartialTensorShape>& |
1840 | output_shapes, const |
1841 | ExperimentalRebatchDataset::Attrs& |
1842 | attrs) { |
1843 | if (!scope.ok()) return; |
1844 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1845 | if (!scope.ok()) return; |
1846 | auto _num_replicas = ::tensorflow::ops::AsNodeOut(scope, num_replicas); |
1847 | if (!scope.ok()) return; |
1848 | ::tensorflow::Node* ret; |
1849 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalRebatchDataset" ); |
1850 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalRebatchDataset" ) |
1851 | .Input(_input_dataset) |
1852 | .Input(_num_replicas) |
1853 | .Attr("output_types" , output_types) |
1854 | .Attr("output_shapes" , output_shapes) |
1855 | .Attr("use_fallback" , attrs.use_fallback_) |
1856 | ; |
1857 | scope.UpdateBuilder(&builder); |
1858 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1859 | if (!scope.ok()) return; |
1860 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1861 | this->operation = Operation(ret); |
1862 | this->handle = Output(ret, 0); |
1863 | } |
1864 | |
1865 | ExperimentalRebatchDataset::ExperimentalRebatchDataset(const |
1866 | ::tensorflow::Scope& |
1867 | scope, |
1868 | ::tensorflow::Input |
1869 | input_dataset, |
1870 | ::tensorflow::Input |
1871 | num_replicas, const |
1872 | DataTypeSlice& |
1873 | output_types, const |
1874 | gtl::ArraySlice<PartialTensorShape>& |
1875 | output_shapes) |
1876 | : ExperimentalRebatchDataset(scope, input_dataset, num_replicas, output_types, output_shapes, ExperimentalRebatchDataset::Attrs()) {} |
1877 | |
1878 | ExperimentalScanDataset::ExperimentalScanDataset(const ::tensorflow::Scope& |
1879 | scope, ::tensorflow::Input |
1880 | input_dataset, |
1881 | ::tensorflow::InputList |
1882 | initial_state, |
1883 | ::tensorflow::InputList |
1884 | other_arguments, const |
1885 | NameAttrList& f, const |
1886 | DataTypeSlice& output_types, |
1887 | const |
1888 | gtl::ArraySlice<PartialTensorShape>& |
1889 | output_shapes, const |
1890 | ExperimentalScanDataset::Attrs& |
1891 | attrs) { |
1892 | if (!scope.ok()) return; |
1893 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1894 | if (!scope.ok()) return; |
1895 | auto _initial_state = ::tensorflow::ops::AsNodeOutList(scope, initial_state); |
1896 | if (!scope.ok()) return; |
1897 | auto _other_arguments = ::tensorflow::ops::AsNodeOutList(scope, other_arguments); |
1898 | if (!scope.ok()) return; |
1899 | ::tensorflow::Node* ret; |
1900 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalScanDataset" ); |
1901 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalScanDataset" ) |
1902 | .Input(_input_dataset) |
1903 | .Input(_initial_state) |
1904 | .Input(_other_arguments) |
1905 | .Attr("f" , f) |
1906 | .Attr("output_types" , output_types) |
1907 | .Attr("output_shapes" , output_shapes) |
1908 | .Attr("preserve_cardinality" , attrs.preserve_cardinality_) |
1909 | ; |
1910 | scope.UpdateBuilder(&builder); |
1911 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1912 | if (!scope.ok()) return; |
1913 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1914 | this->operation = Operation(ret); |
1915 | this->handle = Output(ret, 0); |
1916 | } |
1917 | |
1918 | ExperimentalScanDataset::ExperimentalScanDataset(const ::tensorflow::Scope& |
1919 | scope, ::tensorflow::Input |
1920 | input_dataset, |
1921 | ::tensorflow::InputList |
1922 | initial_state, |
1923 | ::tensorflow::InputList |
1924 | other_arguments, const |
1925 | NameAttrList& f, const |
1926 | DataTypeSlice& output_types, |
1927 | const |
1928 | gtl::ArraySlice<PartialTensorShape>& |
1929 | output_shapes) |
1930 | : ExperimentalScanDataset(scope, input_dataset, initial_state, other_arguments, f, output_types, output_shapes, ExperimentalScanDataset::Attrs()) {} |
1931 | |
1932 | ExperimentalSetStatsAggregatorDataset::ExperimentalSetStatsAggregatorDataset(const |
1933 | ::tensorflow::Scope& |
1934 | scope, |
1935 | ::tensorflow::Input |
1936 | input_dataset, |
1937 | ::tensorflow::Input |
1938 | stats_aggregator, |
1939 | ::tensorflow::Input |
1940 | tag, |
1941 | ::tensorflow::Input |
1942 | counter_prefix, |
1943 | const |
1944 | DataTypeSlice& |
1945 | output_types, |
1946 | const |
1947 | gtl::ArraySlice<PartialTensorShape>& |
1948 | output_shapes) { |
1949 | if (!scope.ok()) return; |
1950 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1951 | if (!scope.ok()) return; |
1952 | auto _stats_aggregator = ::tensorflow::ops::AsNodeOut(scope, stats_aggregator); |
1953 | if (!scope.ok()) return; |
1954 | auto _tag = ::tensorflow::ops::AsNodeOut(scope, tag); |
1955 | if (!scope.ok()) return; |
1956 | auto _counter_prefix = ::tensorflow::ops::AsNodeOut(scope, counter_prefix); |
1957 | if (!scope.ok()) return; |
1958 | ::tensorflow::Node* ret; |
1959 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalSetStatsAggregatorDataset" ); |
1960 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalSetStatsAggregatorDataset" ) |
1961 | .Input(_input_dataset) |
1962 | .Input(_stats_aggregator) |
1963 | .Input(_tag) |
1964 | .Input(_counter_prefix) |
1965 | .Attr("output_types" , output_types) |
1966 | .Attr("output_shapes" , output_shapes) |
1967 | ; |
1968 | scope.UpdateBuilder(&builder); |
1969 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
1970 | if (!scope.ok()) return; |
1971 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
1972 | this->operation = Operation(ret); |
1973 | this->handle = Output(ret, 0); |
1974 | } |
1975 | |
1976 | ExperimentalSleepDataset::ExperimentalSleepDataset(const ::tensorflow::Scope& |
1977 | scope, ::tensorflow::Input |
1978 | input_dataset, |
1979 | ::tensorflow::Input |
1980 | sleep_microseconds, const |
1981 | DataTypeSlice& output_types, |
1982 | const |
1983 | gtl::ArraySlice<PartialTensorShape>& |
1984 | output_shapes) { |
1985 | if (!scope.ok()) return; |
1986 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
1987 | if (!scope.ok()) return; |
1988 | auto _sleep_microseconds = ::tensorflow::ops::AsNodeOut(scope, sleep_microseconds); |
1989 | if (!scope.ok()) return; |
1990 | ::tensorflow::Node* ret; |
1991 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalSleepDataset" ); |
1992 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalSleepDataset" ) |
1993 | .Input(_input_dataset) |
1994 | .Input(_sleep_microseconds) |
1995 | .Attr("output_types" , output_types) |
1996 | .Attr("output_shapes" , output_shapes) |
1997 | ; |
1998 | scope.UpdateBuilder(&builder); |
1999 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2000 | if (!scope.ok()) return; |
2001 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2002 | this->operation = Operation(ret); |
2003 | this->handle = Output(ret, 0); |
2004 | } |
2005 | |
2006 | ExperimentalSlidingWindowDataset::ExperimentalSlidingWindowDataset(const |
2007 | ::tensorflow::Scope& |
2008 | scope, |
2009 | ::tensorflow::Input |
2010 | input_dataset, |
2011 | ::tensorflow::Input |
2012 | window_size, |
2013 | ::tensorflow::Input |
2014 | window_shift, |
2015 | ::tensorflow::Input |
2016 | window_stride, |
2017 | const |
2018 | DataTypeSlice& |
2019 | output_types, |
2020 | const |
2021 | gtl::ArraySlice<PartialTensorShape>& |
2022 | output_shapes) { |
2023 | if (!scope.ok()) return; |
2024 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2025 | if (!scope.ok()) return; |
2026 | auto _window_size = ::tensorflow::ops::AsNodeOut(scope, window_size); |
2027 | if (!scope.ok()) return; |
2028 | auto _window_shift = ::tensorflow::ops::AsNodeOut(scope, window_shift); |
2029 | if (!scope.ok()) return; |
2030 | auto _window_stride = ::tensorflow::ops::AsNodeOut(scope, window_stride); |
2031 | if (!scope.ok()) return; |
2032 | ::tensorflow::Node* ret; |
2033 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalSlidingWindowDataset" ); |
2034 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalSlidingWindowDataset" ) |
2035 | .Input(_input_dataset) |
2036 | .Input(_window_size) |
2037 | .Input(_window_shift) |
2038 | .Input(_window_stride) |
2039 | .Attr("output_types" , output_types) |
2040 | .Attr("output_shapes" , output_shapes) |
2041 | ; |
2042 | scope.UpdateBuilder(&builder); |
2043 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2044 | if (!scope.ok()) return; |
2045 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2046 | this->operation = Operation(ret); |
2047 | this->handle = Output(ret, 0); |
2048 | } |
2049 | |
2050 | ExperimentalSqlDataset::ExperimentalSqlDataset(const ::tensorflow::Scope& |
2051 | scope, ::tensorflow::Input |
2052 | driver_name, ::tensorflow::Input |
2053 | data_source_name, |
2054 | ::tensorflow::Input query, const |
2055 | DataTypeSlice& output_types, |
2056 | const |
2057 | gtl::ArraySlice<PartialTensorShape>& |
2058 | output_shapes) { |
2059 | if (!scope.ok()) return; |
2060 | auto _driver_name = ::tensorflow::ops::AsNodeOut(scope, driver_name); |
2061 | if (!scope.ok()) return; |
2062 | auto _data_source_name = ::tensorflow::ops::AsNodeOut(scope, data_source_name); |
2063 | if (!scope.ok()) return; |
2064 | auto _query = ::tensorflow::ops::AsNodeOut(scope, query); |
2065 | if (!scope.ok()) return; |
2066 | ::tensorflow::Node* ret; |
2067 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalSqlDataset" ); |
2068 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalSqlDataset" ) |
2069 | .Input(_driver_name) |
2070 | .Input(_data_source_name) |
2071 | .Input(_query) |
2072 | .Attr("output_types" , output_types) |
2073 | .Attr("output_shapes" , output_shapes) |
2074 | ; |
2075 | scope.UpdateBuilder(&builder); |
2076 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2077 | if (!scope.ok()) return; |
2078 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2079 | this->operation = Operation(ret); |
2080 | this->handle = Output(ret, 0); |
2081 | } |
2082 | |
2083 | ExperimentalStatsAggregatorHandle::ExperimentalStatsAggregatorHandle(const |
2084 | ::tensorflow::Scope& |
2085 | scope, |
2086 | const |
2087 | ExperimentalStatsAggregatorHandle::Attrs& |
2088 | attrs) { |
2089 | if (!scope.ok()) return; |
2090 | ::tensorflow::Node* ret; |
2091 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalStatsAggregatorHandle" ); |
2092 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalStatsAggregatorHandle" ) |
2093 | .Attr("container" , attrs.container_) |
2094 | .Attr("shared_name" , attrs.shared_name_) |
2095 | ; |
2096 | scope.UpdateBuilder(&builder); |
2097 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2098 | if (!scope.ok()) return; |
2099 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2100 | this->operation = Operation(ret); |
2101 | this->handle = Output(ret, 0); |
2102 | } |
2103 | |
2104 | ExperimentalStatsAggregatorHandle::ExperimentalStatsAggregatorHandle(const |
2105 | ::tensorflow::Scope& |
2106 | scope) |
2107 | : ExperimentalStatsAggregatorHandle(scope, ExperimentalStatsAggregatorHandle::Attrs()) {} |
2108 | |
2109 | ExperimentalStatsAggregatorSummary::ExperimentalStatsAggregatorSummary(const |
2110 | ::tensorflow::Scope& |
2111 | scope, |
2112 | ::tensorflow::Input |
2113 | iterator) { |
2114 | if (!scope.ok()) return; |
2115 | auto _iterator = ::tensorflow::ops::AsNodeOut(scope, iterator); |
2116 | if (!scope.ok()) return; |
2117 | ::tensorflow::Node* ret; |
2118 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalStatsAggregatorSummary" ); |
2119 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalStatsAggregatorSummary" ) |
2120 | .Input(_iterator) |
2121 | ; |
2122 | scope.UpdateBuilder(&builder); |
2123 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2124 | if (!scope.ok()) return; |
2125 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2126 | this->operation = Operation(ret); |
2127 | this->summary = Output(ret, 0); |
2128 | } |
2129 | |
2130 | ExperimentalTakeWhileDataset::ExperimentalTakeWhileDataset(const |
2131 | ::tensorflow::Scope& |
2132 | scope, |
2133 | ::tensorflow::Input |
2134 | input_dataset, |
2135 | ::tensorflow::InputList |
2136 | other_arguments, |
2137 | const NameAttrList& |
2138 | predicate, const |
2139 | DataTypeSlice& |
2140 | output_types, const |
2141 | gtl::ArraySlice<PartialTensorShape>& |
2142 | output_shapes) { |
2143 | if (!scope.ok()) return; |
2144 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2145 | if (!scope.ok()) return; |
2146 | auto _other_arguments = ::tensorflow::ops::AsNodeOutList(scope, other_arguments); |
2147 | if (!scope.ok()) return; |
2148 | ::tensorflow::Node* ret; |
2149 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalTakeWhileDataset" ); |
2150 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalTakeWhileDataset" ) |
2151 | .Input(_input_dataset) |
2152 | .Input(_other_arguments) |
2153 | .Attr("predicate" , predicate) |
2154 | .Attr("output_types" , output_types) |
2155 | .Attr("output_shapes" , output_shapes) |
2156 | ; |
2157 | scope.UpdateBuilder(&builder); |
2158 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2159 | if (!scope.ok()) return; |
2160 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2161 | this->operation = Operation(ret); |
2162 | this->handle = Output(ret, 0); |
2163 | } |
2164 | |
2165 | ExperimentalThreadPoolDataset::ExperimentalThreadPoolDataset(const |
2166 | ::tensorflow::Scope& |
2167 | scope, |
2168 | ::tensorflow::Input |
2169 | input_dataset, |
2170 | ::tensorflow::Input |
2171 | thread_pool, const |
2172 | DataTypeSlice& |
2173 | output_types, |
2174 | const |
2175 | gtl::ArraySlice<PartialTensorShape>& |
2176 | output_shapes) { |
2177 | if (!scope.ok()) return; |
2178 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2179 | if (!scope.ok()) return; |
2180 | auto _thread_pool = ::tensorflow::ops::AsNodeOut(scope, thread_pool); |
2181 | if (!scope.ok()) return; |
2182 | ::tensorflow::Node* ret; |
2183 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalThreadPoolDataset" ); |
2184 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalThreadPoolDataset" ) |
2185 | .Input(_input_dataset) |
2186 | .Input(_thread_pool) |
2187 | .Attr("output_types" , output_types) |
2188 | .Attr("output_shapes" , output_shapes) |
2189 | ; |
2190 | scope.UpdateBuilder(&builder); |
2191 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2192 | if (!scope.ok()) return; |
2193 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2194 | this->operation = Operation(ret); |
2195 | this->handle = Output(ret, 0); |
2196 | } |
2197 | |
2198 | ExperimentalThreadPoolHandle::ExperimentalThreadPoolHandle(const |
2199 | ::tensorflow::Scope& |
2200 | scope, int64 |
2201 | num_threads, |
2202 | StringPiece |
2203 | display_name, const |
2204 | ExperimentalThreadPoolHandle::Attrs& |
2205 | attrs) { |
2206 | if (!scope.ok()) return; |
2207 | ::tensorflow::Node* ret; |
2208 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalThreadPoolHandle" ); |
2209 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalThreadPoolHandle" ) |
2210 | .Attr("num_threads" , num_threads) |
2211 | .Attr("max_intra_op_parallelism" , attrs.max_intra_op_parallelism_) |
2212 | .Attr("display_name" , display_name) |
2213 | .Attr("container" , attrs.container_) |
2214 | .Attr("shared_name" , attrs.shared_name_) |
2215 | ; |
2216 | scope.UpdateBuilder(&builder); |
2217 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2218 | if (!scope.ok()) return; |
2219 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2220 | this->operation = Operation(ret); |
2221 | this->handle = Output(ret, 0); |
2222 | } |
2223 | |
2224 | ExperimentalThreadPoolHandle::ExperimentalThreadPoolHandle(const |
2225 | ::tensorflow::Scope& |
2226 | scope, int64 |
2227 | num_threads, |
2228 | StringPiece |
2229 | display_name) |
2230 | : ExperimentalThreadPoolHandle(scope, num_threads, display_name, ExperimentalThreadPoolHandle::Attrs()) {} |
2231 | |
2232 | ExperimentalUnbatchDataset::ExperimentalUnbatchDataset(const |
2233 | ::tensorflow::Scope& |
2234 | scope, |
2235 | ::tensorflow::Input |
2236 | input_dataset, const |
2237 | DataTypeSlice& |
2238 | output_types, const |
2239 | gtl::ArraySlice<PartialTensorShape>& |
2240 | output_shapes) { |
2241 | if (!scope.ok()) return; |
2242 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2243 | if (!scope.ok()) return; |
2244 | ::tensorflow::Node* ret; |
2245 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalUnbatchDataset" ); |
2246 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalUnbatchDataset" ) |
2247 | .Input(_input_dataset) |
2248 | .Attr("output_types" , output_types) |
2249 | .Attr("output_shapes" , output_shapes) |
2250 | ; |
2251 | scope.UpdateBuilder(&builder); |
2252 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2253 | if (!scope.ok()) return; |
2254 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2255 | this->operation = Operation(ret); |
2256 | this->handle = Output(ret, 0); |
2257 | } |
2258 | |
2259 | ExperimentalUniqueDataset::ExperimentalUniqueDataset(const ::tensorflow::Scope& |
2260 | scope, ::tensorflow::Input |
2261 | input_dataset, const |
2262 | DataTypeSlice& |
2263 | output_types, const |
2264 | gtl::ArraySlice<PartialTensorShape>& |
2265 | output_shapes) { |
2266 | if (!scope.ok()) return; |
2267 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2268 | if (!scope.ok()) return; |
2269 | ::tensorflow::Node* ret; |
2270 | const auto unique_name = scope.GetUniqueNameForOp("ExperimentalUniqueDataset" ); |
2271 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ExperimentalUniqueDataset" ) |
2272 | .Input(_input_dataset) |
2273 | .Attr("output_types" , output_types) |
2274 | .Attr("output_shapes" , output_shapes) |
2275 | ; |
2276 | scope.UpdateBuilder(&builder); |
2277 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2278 | if (!scope.ok()) return; |
2279 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2280 | this->operation = Operation(ret); |
2281 | this->handle = Output(ret, 0); |
2282 | } |
2283 | |
2284 | GetElementAtIndex::GetElementAtIndex(const ::tensorflow::Scope& scope, |
2285 | ::tensorflow::Input dataset, |
2286 | ::tensorflow::Input index, const |
2287 | DataTypeSlice& output_types, const |
2288 | gtl::ArraySlice<PartialTensorShape>& |
2289 | output_shapes) { |
2290 | if (!scope.ok()) return; |
2291 | auto _dataset = ::tensorflow::ops::AsNodeOut(scope, dataset); |
2292 | if (!scope.ok()) return; |
2293 | auto _index = ::tensorflow::ops::AsNodeOut(scope, index); |
2294 | if (!scope.ok()) return; |
2295 | ::tensorflow::Node* ret; |
2296 | const auto unique_name = scope.GetUniqueNameForOp("GetElementAtIndex" ); |
2297 | auto builder = ::tensorflow::NodeBuilder(unique_name, "GetElementAtIndex" ) |
2298 | .Input(_dataset) |
2299 | .Input(_index) |
2300 | .Attr("output_types" , output_types) |
2301 | .Attr("output_shapes" , output_shapes) |
2302 | ; |
2303 | scope.UpdateBuilder(&builder); |
2304 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2305 | if (!scope.ok()) return; |
2306 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2307 | this->operation = Operation(ret); |
2308 | for (int32 i = 0; i < ret->num_outputs(); ++i) |
2309 | this->components.push_back(Output(ret, i)); |
2310 | } |
2311 | |
2312 | GroupByReducerDataset::GroupByReducerDataset(const ::tensorflow::Scope& scope, |
2313 | ::tensorflow::Input input_dataset, |
2314 | ::tensorflow::InputList |
2315 | key_func_other_arguments, |
2316 | ::tensorflow::InputList |
2317 | init_func_other_arguments, |
2318 | ::tensorflow::InputList |
2319 | reduce_func_other_arguments, |
2320 | ::tensorflow::InputList |
2321 | finalize_func_other_arguments, |
2322 | const NameAttrList& key_func, |
2323 | const NameAttrList& init_func, |
2324 | const NameAttrList& reduce_func, |
2325 | const NameAttrList& finalize_func, |
2326 | const DataTypeSlice& output_types, |
2327 | const |
2328 | gtl::ArraySlice<PartialTensorShape>& |
2329 | output_shapes) { |
2330 | if (!scope.ok()) return; |
2331 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2332 | if (!scope.ok()) return; |
2333 | auto _key_func_other_arguments = ::tensorflow::ops::AsNodeOutList(scope, key_func_other_arguments); |
2334 | if (!scope.ok()) return; |
2335 | auto _init_func_other_arguments = ::tensorflow::ops::AsNodeOutList(scope, init_func_other_arguments); |
2336 | if (!scope.ok()) return; |
2337 | auto _reduce_func_other_arguments = ::tensorflow::ops::AsNodeOutList(scope, reduce_func_other_arguments); |
2338 | if (!scope.ok()) return; |
2339 | auto _finalize_func_other_arguments = ::tensorflow::ops::AsNodeOutList(scope, finalize_func_other_arguments); |
2340 | if (!scope.ok()) return; |
2341 | ::tensorflow::Node* ret; |
2342 | const auto unique_name = scope.GetUniqueNameForOp("GroupByReducerDataset" ); |
2343 | auto builder = ::tensorflow::NodeBuilder(unique_name, "GroupByReducerDataset" ) |
2344 | .Input(_input_dataset) |
2345 | .Input(_key_func_other_arguments) |
2346 | .Input(_init_func_other_arguments) |
2347 | .Input(_reduce_func_other_arguments) |
2348 | .Input(_finalize_func_other_arguments) |
2349 | .Attr("key_func" , key_func) |
2350 | .Attr("init_func" , init_func) |
2351 | .Attr("reduce_func" , reduce_func) |
2352 | .Attr("finalize_func" , finalize_func) |
2353 | .Attr("output_types" , output_types) |
2354 | .Attr("output_shapes" , output_shapes) |
2355 | ; |
2356 | scope.UpdateBuilder(&builder); |
2357 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2358 | if (!scope.ok()) return; |
2359 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2360 | this->operation = Operation(ret); |
2361 | this->handle = Output(ret, 0); |
2362 | } |
2363 | |
2364 | GroupByWindowDataset::GroupByWindowDataset(const ::tensorflow::Scope& scope, |
2365 | ::tensorflow::Input input_dataset, |
2366 | ::tensorflow::InputList |
2367 | key_func_other_arguments, |
2368 | ::tensorflow::InputList |
2369 | reduce_func_other_arguments, |
2370 | ::tensorflow::InputList |
2371 | window_size_func_other_arguments, |
2372 | const NameAttrList& key_func, const |
2373 | NameAttrList& reduce_func, const |
2374 | NameAttrList& window_size_func, |
2375 | const DataTypeSlice& output_types, |
2376 | const |
2377 | gtl::ArraySlice<PartialTensorShape>& |
2378 | output_shapes, const |
2379 | GroupByWindowDataset::Attrs& attrs) { |
2380 | if (!scope.ok()) return; |
2381 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2382 | if (!scope.ok()) return; |
2383 | auto _key_func_other_arguments = ::tensorflow::ops::AsNodeOutList(scope, key_func_other_arguments); |
2384 | if (!scope.ok()) return; |
2385 | auto _reduce_func_other_arguments = ::tensorflow::ops::AsNodeOutList(scope, reduce_func_other_arguments); |
2386 | if (!scope.ok()) return; |
2387 | auto _window_size_func_other_arguments = ::tensorflow::ops::AsNodeOutList(scope, window_size_func_other_arguments); |
2388 | if (!scope.ok()) return; |
2389 | ::tensorflow::Node* ret; |
2390 | const auto unique_name = scope.GetUniqueNameForOp("GroupByWindowDataset" ); |
2391 | auto builder = ::tensorflow::NodeBuilder(unique_name, "GroupByWindowDataset" ) |
2392 | .Input(_input_dataset) |
2393 | .Input(_key_func_other_arguments) |
2394 | .Input(_reduce_func_other_arguments) |
2395 | .Input(_window_size_func_other_arguments) |
2396 | .Attr("key_func" , key_func) |
2397 | .Attr("reduce_func" , reduce_func) |
2398 | .Attr("window_size_func" , window_size_func) |
2399 | .Attr("output_types" , output_types) |
2400 | .Attr("output_shapes" , output_shapes) |
2401 | .Attr("metadata" , attrs.metadata_) |
2402 | ; |
2403 | scope.UpdateBuilder(&builder); |
2404 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2405 | if (!scope.ok()) return; |
2406 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2407 | this->operation = Operation(ret); |
2408 | this->handle = Output(ret, 0); |
2409 | } |
2410 | |
2411 | GroupByWindowDataset::GroupByWindowDataset(const ::tensorflow::Scope& scope, |
2412 | ::tensorflow::Input input_dataset, |
2413 | ::tensorflow::InputList |
2414 | key_func_other_arguments, |
2415 | ::tensorflow::InputList |
2416 | reduce_func_other_arguments, |
2417 | ::tensorflow::InputList |
2418 | window_size_func_other_arguments, |
2419 | const NameAttrList& key_func, const |
2420 | NameAttrList& reduce_func, const |
2421 | NameAttrList& window_size_func, |
2422 | const DataTypeSlice& output_types, |
2423 | const |
2424 | gtl::ArraySlice<PartialTensorShape>& |
2425 | output_shapes) |
2426 | : GroupByWindowDataset(scope, input_dataset, key_func_other_arguments, reduce_func_other_arguments, window_size_func_other_arguments, key_func, reduce_func, window_size_func, output_types, output_shapes, GroupByWindowDataset::Attrs()) {} |
2427 | |
2428 | IgnoreErrorsDataset::IgnoreErrorsDataset(const ::tensorflow::Scope& scope, |
2429 | ::tensorflow::Input input_dataset, |
2430 | const DataTypeSlice& output_types, |
2431 | const |
2432 | gtl::ArraySlice<PartialTensorShape>& |
2433 | output_shapes, const |
2434 | IgnoreErrorsDataset::Attrs& attrs) { |
2435 | if (!scope.ok()) return; |
2436 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2437 | if (!scope.ok()) return; |
2438 | ::tensorflow::Node* ret; |
2439 | const auto unique_name = scope.GetUniqueNameForOp("IgnoreErrorsDataset" ); |
2440 | auto builder = ::tensorflow::NodeBuilder(unique_name, "IgnoreErrorsDataset" ) |
2441 | .Input(_input_dataset) |
2442 | .Attr("output_types" , output_types) |
2443 | .Attr("output_shapes" , output_shapes) |
2444 | .Attr("log_warning" , attrs.log_warning_) |
2445 | ; |
2446 | scope.UpdateBuilder(&builder); |
2447 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2448 | if (!scope.ok()) return; |
2449 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2450 | this->operation = Operation(ret); |
2451 | this->handle = Output(ret, 0); |
2452 | } |
2453 | |
2454 | IgnoreErrorsDataset::IgnoreErrorsDataset(const ::tensorflow::Scope& scope, |
2455 | ::tensorflow::Input input_dataset, |
2456 | const DataTypeSlice& output_types, |
2457 | const |
2458 | gtl::ArraySlice<PartialTensorShape>& |
2459 | output_shapes) |
2460 | : IgnoreErrorsDataset(scope, input_dataset, output_types, output_shapes, IgnoreErrorsDataset::Attrs()) {} |
2461 | |
2462 | InitializeTableFromDataset::InitializeTableFromDataset(const |
2463 | ::tensorflow::Scope& |
2464 | scope, |
2465 | ::tensorflow::Input |
2466 | table_handle, |
2467 | ::tensorflow::Input |
2468 | dataset) { |
2469 | if (!scope.ok()) return; |
2470 | auto _table_handle = ::tensorflow::ops::AsNodeOut(scope, table_handle); |
2471 | if (!scope.ok()) return; |
2472 | auto _dataset = ::tensorflow::ops::AsNodeOut(scope, dataset); |
2473 | if (!scope.ok()) return; |
2474 | ::tensorflow::Node* ret; |
2475 | const auto unique_name = scope.GetUniqueNameForOp("InitializeTableFromDataset" ); |
2476 | auto builder = ::tensorflow::NodeBuilder(unique_name, "InitializeTableFromDataset" ) |
2477 | .Input(_table_handle) |
2478 | .Input(_dataset) |
2479 | ; |
2480 | scope.UpdateBuilder(&builder); |
2481 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2482 | if (!scope.ok()) return; |
2483 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2484 | this->operation = Operation(ret); |
2485 | return; |
2486 | } |
2487 | |
2488 | IteratorGetDevice::IteratorGetDevice(const ::tensorflow::Scope& scope, |
2489 | ::tensorflow::Input resource) { |
2490 | if (!scope.ok()) return; |
2491 | auto _resource = ::tensorflow::ops::AsNodeOut(scope, resource); |
2492 | if (!scope.ok()) return; |
2493 | ::tensorflow::Node* ret; |
2494 | const auto unique_name = scope.GetUniqueNameForOp("IteratorGetDevice" ); |
2495 | auto builder = ::tensorflow::NodeBuilder(unique_name, "IteratorGetDevice" ) |
2496 | .Input(_resource) |
2497 | ; |
2498 | scope.UpdateBuilder(&builder); |
2499 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2500 | if (!scope.ok()) return; |
2501 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2502 | this->operation = Operation(ret); |
2503 | this->device = Output(ret, 0); |
2504 | } |
2505 | |
2506 | LMDBDataset::LMDBDataset(const ::tensorflow::Scope& scope, ::tensorflow::Input |
2507 | filenames, const DataTypeSlice& output_types, const |
2508 | gtl::ArraySlice<PartialTensorShape>& output_shapes) { |
2509 | if (!scope.ok()) return; |
2510 | auto _filenames = ::tensorflow::ops::AsNodeOut(scope, filenames); |
2511 | if (!scope.ok()) return; |
2512 | ::tensorflow::Node* ret; |
2513 | const auto unique_name = scope.GetUniqueNameForOp("LMDBDataset" ); |
2514 | auto builder = ::tensorflow::NodeBuilder(unique_name, "LMDBDataset" ) |
2515 | .Input(_filenames) |
2516 | .Attr("output_types" , output_types) |
2517 | .Attr("output_shapes" , output_shapes) |
2518 | ; |
2519 | scope.UpdateBuilder(&builder); |
2520 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2521 | if (!scope.ok()) return; |
2522 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2523 | this->operation = Operation(ret); |
2524 | this->handle = Output(ret, 0); |
2525 | } |
2526 | |
2527 | LatencyStatsDataset::LatencyStatsDataset(const ::tensorflow::Scope& scope, |
2528 | ::tensorflow::Input input_dataset, |
2529 | ::tensorflow::Input tag, const |
2530 | DataTypeSlice& output_types, const |
2531 | gtl::ArraySlice<PartialTensorShape>& |
2532 | output_shapes) { |
2533 | if (!scope.ok()) return; |
2534 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2535 | if (!scope.ok()) return; |
2536 | auto _tag = ::tensorflow::ops::AsNodeOut(scope, tag); |
2537 | if (!scope.ok()) return; |
2538 | ::tensorflow::Node* ret; |
2539 | const auto unique_name = scope.GetUniqueNameForOp("LatencyStatsDataset" ); |
2540 | auto builder = ::tensorflow::NodeBuilder(unique_name, "LatencyStatsDataset" ) |
2541 | .Input(_input_dataset) |
2542 | .Input(_tag) |
2543 | .Attr("output_types" , output_types) |
2544 | .Attr("output_shapes" , output_shapes) |
2545 | ; |
2546 | scope.UpdateBuilder(&builder); |
2547 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2548 | if (!scope.ok()) return; |
2549 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2550 | this->operation = Operation(ret); |
2551 | this->handle = Output(ret, 0); |
2552 | } |
2553 | |
2554 | LegacyParallelInterleaveDatasetV2::LegacyParallelInterleaveDatasetV2(const |
2555 | ::tensorflow::Scope& |
2556 | scope, |
2557 | ::tensorflow::Input |
2558 | input_dataset, |
2559 | ::tensorflow::InputList |
2560 | other_arguments, |
2561 | ::tensorflow::Input |
2562 | cycle_length, |
2563 | ::tensorflow::Input |
2564 | block_length, |
2565 | ::tensorflow::Input |
2566 | buffer_output_elements, |
2567 | ::tensorflow::Input |
2568 | prefetch_input_elements, |
2569 | const |
2570 | NameAttrList& |
2571 | f, const |
2572 | DataTypeSlice& |
2573 | output_types, |
2574 | const |
2575 | gtl::ArraySlice<PartialTensorShape>& |
2576 | output_shapes, |
2577 | const |
2578 | LegacyParallelInterleaveDatasetV2::Attrs& |
2579 | attrs) { |
2580 | if (!scope.ok()) return; |
2581 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2582 | if (!scope.ok()) return; |
2583 | auto _other_arguments = ::tensorflow::ops::AsNodeOutList(scope, other_arguments); |
2584 | if (!scope.ok()) return; |
2585 | auto _cycle_length = ::tensorflow::ops::AsNodeOut(scope, cycle_length); |
2586 | if (!scope.ok()) return; |
2587 | auto _block_length = ::tensorflow::ops::AsNodeOut(scope, block_length); |
2588 | if (!scope.ok()) return; |
2589 | auto _buffer_output_elements = ::tensorflow::ops::AsNodeOut(scope, buffer_output_elements); |
2590 | if (!scope.ok()) return; |
2591 | auto _prefetch_input_elements = ::tensorflow::ops::AsNodeOut(scope, prefetch_input_elements); |
2592 | if (!scope.ok()) return; |
2593 | ::tensorflow::Node* ret; |
2594 | const auto unique_name = scope.GetUniqueNameForOp("LegacyParallelInterleaveDatasetV2" ); |
2595 | auto builder = ::tensorflow::NodeBuilder(unique_name, "LegacyParallelInterleaveDatasetV2" ) |
2596 | .Input(_input_dataset) |
2597 | .Input(_other_arguments) |
2598 | .Input(_cycle_length) |
2599 | .Input(_block_length) |
2600 | .Input(_buffer_output_elements) |
2601 | .Input(_prefetch_input_elements) |
2602 | .Attr("f" , f) |
2603 | .Attr("deterministic" , attrs.deterministic_) |
2604 | .Attr("output_types" , output_types) |
2605 | .Attr("output_shapes" , output_shapes) |
2606 | .Attr("metadata" , attrs.metadata_) |
2607 | ; |
2608 | scope.UpdateBuilder(&builder); |
2609 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2610 | if (!scope.ok()) return; |
2611 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2612 | this->operation = Operation(ret); |
2613 | this->handle = Output(ret, 0); |
2614 | } |
2615 | |
2616 | LegacyParallelInterleaveDatasetV2::LegacyParallelInterleaveDatasetV2(const |
2617 | ::tensorflow::Scope& |
2618 | scope, |
2619 | ::tensorflow::Input |
2620 | input_dataset, |
2621 | ::tensorflow::InputList |
2622 | other_arguments, |
2623 | ::tensorflow::Input |
2624 | cycle_length, |
2625 | ::tensorflow::Input |
2626 | block_length, |
2627 | ::tensorflow::Input |
2628 | buffer_output_elements, |
2629 | ::tensorflow::Input |
2630 | prefetch_input_elements, |
2631 | const |
2632 | NameAttrList& |
2633 | f, const |
2634 | DataTypeSlice& |
2635 | output_types, |
2636 | const |
2637 | gtl::ArraySlice<PartialTensorShape>& |
2638 | output_shapes) |
2639 | : LegacyParallelInterleaveDatasetV2(scope, input_dataset, other_arguments, cycle_length, block_length, buffer_output_elements, prefetch_input_elements, f, output_types, output_shapes, LegacyParallelInterleaveDatasetV2::Attrs()) {} |
2640 | |
2641 | ListDataset::ListDataset(const ::tensorflow::Scope& scope, |
2642 | ::tensorflow::InputList tensors, const DataTypeSlice& |
2643 | output_types, const |
2644 | gtl::ArraySlice<PartialTensorShape>& output_shapes, |
2645 | const ListDataset::Attrs& attrs) { |
2646 | if (!scope.ok()) return; |
2647 | auto _tensors = ::tensorflow::ops::AsNodeOutList(scope, tensors); |
2648 | if (!scope.ok()) return; |
2649 | ::tensorflow::Node* ret; |
2650 | const auto unique_name = scope.GetUniqueNameForOp("ListDataset" ); |
2651 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ListDataset" ) |
2652 | .Input(_tensors) |
2653 | .Attr("output_types" , output_types) |
2654 | .Attr("output_shapes" , output_shapes) |
2655 | .Attr("metadata" , attrs.metadata_) |
2656 | ; |
2657 | scope.UpdateBuilder(&builder); |
2658 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2659 | if (!scope.ok()) return; |
2660 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2661 | this->operation = Operation(ret); |
2662 | this->handle = Output(ret, 0); |
2663 | } |
2664 | |
2665 | ListDataset::ListDataset(const ::tensorflow::Scope& scope, |
2666 | ::tensorflow::InputList tensors, const DataTypeSlice& |
2667 | output_types, const |
2668 | gtl::ArraySlice<PartialTensorShape>& output_shapes) |
2669 | : ListDataset(scope, tensors, output_types, output_shapes, ListDataset::Attrs()) {} |
2670 | |
2671 | LoadDataset::LoadDataset(const ::tensorflow::Scope& scope, ::tensorflow::Input |
2672 | path, ::tensorflow::InputList reader_func_other_args, |
2673 | const DataTypeSlice& output_types, const |
2674 | gtl::ArraySlice<PartialTensorShape>& output_shapes, |
2675 | const NameAttrList& reader_func, const |
2676 | LoadDataset::Attrs& attrs) { |
2677 | if (!scope.ok()) return; |
2678 | auto _path = ::tensorflow::ops::AsNodeOut(scope, path); |
2679 | if (!scope.ok()) return; |
2680 | auto _reader_func_other_args = ::tensorflow::ops::AsNodeOutList(scope, reader_func_other_args); |
2681 | if (!scope.ok()) return; |
2682 | ::tensorflow::Node* ret; |
2683 | const auto unique_name = scope.GetUniqueNameForOp("LoadDataset" ); |
2684 | auto builder = ::tensorflow::NodeBuilder(unique_name, "LoadDataset" ) |
2685 | .Input(_path) |
2686 | .Input(_reader_func_other_args) |
2687 | .Attr("output_types" , output_types) |
2688 | .Attr("output_shapes" , output_shapes) |
2689 | .Attr("compression" , attrs.compression_) |
2690 | .Attr("reader_func" , reader_func) |
2691 | ; |
2692 | scope.UpdateBuilder(&builder); |
2693 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2694 | if (!scope.ok()) return; |
2695 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2696 | this->operation = Operation(ret); |
2697 | this->handle = Output(ret, 0); |
2698 | } |
2699 | |
2700 | LoadDataset::LoadDataset(const ::tensorflow::Scope& scope, ::tensorflow::Input |
2701 | path, ::tensorflow::InputList reader_func_other_args, |
2702 | const DataTypeSlice& output_types, const |
2703 | gtl::ArraySlice<PartialTensorShape>& output_shapes, |
2704 | const NameAttrList& reader_func) |
2705 | : LoadDataset(scope, path, reader_func_other_args, output_types, output_shapes, reader_func, LoadDataset::Attrs()) {} |
2706 | |
2707 | MapAndBatchDataset::MapAndBatchDataset(const ::tensorflow::Scope& scope, |
2708 | ::tensorflow::Input input_dataset, |
2709 | ::tensorflow::InputList other_arguments, |
2710 | ::tensorflow::Input batch_size, |
2711 | ::tensorflow::Input num_parallel_calls, |
2712 | ::tensorflow::Input drop_remainder, |
2713 | const NameAttrList& f, const |
2714 | DataTypeSlice& output_types, const |
2715 | gtl::ArraySlice<PartialTensorShape>& |
2716 | output_shapes, const |
2717 | MapAndBatchDataset::Attrs& attrs) { |
2718 | if (!scope.ok()) return; |
2719 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2720 | if (!scope.ok()) return; |
2721 | auto _other_arguments = ::tensorflow::ops::AsNodeOutList(scope, other_arguments); |
2722 | if (!scope.ok()) return; |
2723 | auto _batch_size = ::tensorflow::ops::AsNodeOut(scope, batch_size); |
2724 | if (!scope.ok()) return; |
2725 | auto _num_parallel_calls = ::tensorflow::ops::AsNodeOut(scope, num_parallel_calls); |
2726 | if (!scope.ok()) return; |
2727 | auto _drop_remainder = ::tensorflow::ops::AsNodeOut(scope, drop_remainder); |
2728 | if (!scope.ok()) return; |
2729 | ::tensorflow::Node* ret; |
2730 | const auto unique_name = scope.GetUniqueNameForOp("MapAndBatchDataset" ); |
2731 | auto builder = ::tensorflow::NodeBuilder(unique_name, "MapAndBatchDataset" ) |
2732 | .Input(_input_dataset) |
2733 | .Input(_other_arguments) |
2734 | .Input(_batch_size) |
2735 | .Input(_num_parallel_calls) |
2736 | .Input(_drop_remainder) |
2737 | .Attr("f" , f) |
2738 | .Attr("output_types" , output_types) |
2739 | .Attr("output_shapes" , output_shapes) |
2740 | .Attr("preserve_cardinality" , attrs.preserve_cardinality_) |
2741 | .Attr("metadata" , attrs.metadata_) |
2742 | ; |
2743 | scope.UpdateBuilder(&builder); |
2744 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2745 | if (!scope.ok()) return; |
2746 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2747 | this->operation = Operation(ret); |
2748 | this->handle = Output(ret, 0); |
2749 | } |
2750 | |
2751 | MapAndBatchDataset::MapAndBatchDataset(const ::tensorflow::Scope& scope, |
2752 | ::tensorflow::Input input_dataset, |
2753 | ::tensorflow::InputList other_arguments, |
2754 | ::tensorflow::Input batch_size, |
2755 | ::tensorflow::Input num_parallel_calls, |
2756 | ::tensorflow::Input drop_remainder, |
2757 | const NameAttrList& f, const |
2758 | DataTypeSlice& output_types, const |
2759 | gtl::ArraySlice<PartialTensorShape>& |
2760 | output_shapes) |
2761 | : MapAndBatchDataset(scope, input_dataset, other_arguments, batch_size, num_parallel_calls, drop_remainder, f, output_types, output_shapes, MapAndBatchDataset::Attrs()) {} |
2762 | |
2763 | MatchingFilesDataset::MatchingFilesDataset(const ::tensorflow::Scope& scope, |
2764 | ::tensorflow::Input patterns) { |
2765 | if (!scope.ok()) return; |
2766 | auto _patterns = ::tensorflow::ops::AsNodeOut(scope, patterns); |
2767 | if (!scope.ok()) return; |
2768 | ::tensorflow::Node* ret; |
2769 | const auto unique_name = scope.GetUniqueNameForOp("MatchingFilesDataset" ); |
2770 | auto builder = ::tensorflow::NodeBuilder(unique_name, "MatchingFilesDataset" ) |
2771 | .Input(_patterns) |
2772 | ; |
2773 | scope.UpdateBuilder(&builder); |
2774 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2775 | if (!scope.ok()) return; |
2776 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2777 | this->operation = Operation(ret); |
2778 | this->handle = Output(ret, 0); |
2779 | } |
2780 | |
2781 | MaxIntraOpParallelismDataset::MaxIntraOpParallelismDataset(const |
2782 | ::tensorflow::Scope& |
2783 | scope, |
2784 | ::tensorflow::Input |
2785 | input_dataset, |
2786 | ::tensorflow::Input |
2787 | max_intra_op_parallelism, |
2788 | const DataTypeSlice& |
2789 | output_types, const |
2790 | gtl::ArraySlice<PartialTensorShape>& |
2791 | output_shapes) { |
2792 | if (!scope.ok()) return; |
2793 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2794 | if (!scope.ok()) return; |
2795 | auto _max_intra_op_parallelism = ::tensorflow::ops::AsNodeOut(scope, max_intra_op_parallelism); |
2796 | if (!scope.ok()) return; |
2797 | ::tensorflow::Node* ret; |
2798 | const auto unique_name = scope.GetUniqueNameForOp("MaxIntraOpParallelismDataset" ); |
2799 | auto builder = ::tensorflow::NodeBuilder(unique_name, "MaxIntraOpParallelismDataset" ) |
2800 | .Input(_input_dataset) |
2801 | .Input(_max_intra_op_parallelism) |
2802 | .Attr("output_types" , output_types) |
2803 | .Attr("output_shapes" , output_shapes) |
2804 | ; |
2805 | scope.UpdateBuilder(&builder); |
2806 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2807 | if (!scope.ok()) return; |
2808 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2809 | this->operation = Operation(ret); |
2810 | this->handle = Output(ret, 0); |
2811 | } |
2812 | |
2813 | NonSerializableDataset::NonSerializableDataset(const ::tensorflow::Scope& |
2814 | scope, ::tensorflow::Input |
2815 | input_dataset, const |
2816 | DataTypeSlice& output_types, |
2817 | const |
2818 | gtl::ArraySlice<PartialTensorShape>& |
2819 | output_shapes) { |
2820 | if (!scope.ok()) return; |
2821 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2822 | if (!scope.ok()) return; |
2823 | ::tensorflow::Node* ret; |
2824 | const auto unique_name = scope.GetUniqueNameForOp("NonSerializableDataset" ); |
2825 | auto builder = ::tensorflow::NodeBuilder(unique_name, "NonSerializableDataset" ) |
2826 | .Input(_input_dataset) |
2827 | .Attr("output_types" , output_types) |
2828 | .Attr("output_shapes" , output_shapes) |
2829 | ; |
2830 | scope.UpdateBuilder(&builder); |
2831 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2832 | if (!scope.ok()) return; |
2833 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2834 | this->operation = Operation(ret); |
2835 | this->handle = Output(ret, 0); |
2836 | } |
2837 | |
2838 | ParallelInterleaveDataset::ParallelInterleaveDataset(const ::tensorflow::Scope& |
2839 | scope, ::tensorflow::Input |
2840 | input_dataset, |
2841 | ::tensorflow::InputList |
2842 | other_arguments, |
2843 | ::tensorflow::Input |
2844 | cycle_length, |
2845 | ::tensorflow::Input |
2846 | block_length, |
2847 | ::tensorflow::Input |
2848 | sloppy, |
2849 | ::tensorflow::Input |
2850 | buffer_output_elements, |
2851 | ::tensorflow::Input |
2852 | prefetch_input_elements, |
2853 | const NameAttrList& f, |
2854 | const DataTypeSlice& |
2855 | output_types, const |
2856 | gtl::ArraySlice<PartialTensorShape>& |
2857 | output_shapes, const |
2858 | ParallelInterleaveDataset::Attrs& |
2859 | attrs) { |
2860 | if (!scope.ok()) return; |
2861 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2862 | if (!scope.ok()) return; |
2863 | auto _other_arguments = ::tensorflow::ops::AsNodeOutList(scope, other_arguments); |
2864 | if (!scope.ok()) return; |
2865 | auto _cycle_length = ::tensorflow::ops::AsNodeOut(scope, cycle_length); |
2866 | if (!scope.ok()) return; |
2867 | auto _block_length = ::tensorflow::ops::AsNodeOut(scope, block_length); |
2868 | if (!scope.ok()) return; |
2869 | auto _sloppy = ::tensorflow::ops::AsNodeOut(scope, sloppy); |
2870 | if (!scope.ok()) return; |
2871 | auto _buffer_output_elements = ::tensorflow::ops::AsNodeOut(scope, buffer_output_elements); |
2872 | if (!scope.ok()) return; |
2873 | auto _prefetch_input_elements = ::tensorflow::ops::AsNodeOut(scope, prefetch_input_elements); |
2874 | if (!scope.ok()) return; |
2875 | ::tensorflow::Node* ret; |
2876 | const auto unique_name = scope.GetUniqueNameForOp("ParallelInterleaveDataset" ); |
2877 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ParallelInterleaveDataset" ) |
2878 | .Input(_input_dataset) |
2879 | .Input(_other_arguments) |
2880 | .Input(_cycle_length) |
2881 | .Input(_block_length) |
2882 | .Input(_sloppy) |
2883 | .Input(_buffer_output_elements) |
2884 | .Input(_prefetch_input_elements) |
2885 | .Attr("f" , f) |
2886 | .Attr("output_types" , output_types) |
2887 | .Attr("output_shapes" , output_shapes) |
2888 | .Attr("metadata" , attrs.metadata_) |
2889 | ; |
2890 | scope.UpdateBuilder(&builder); |
2891 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2892 | if (!scope.ok()) return; |
2893 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2894 | this->operation = Operation(ret); |
2895 | this->handle = Output(ret, 0); |
2896 | } |
2897 | |
2898 | ParallelInterleaveDataset::ParallelInterleaveDataset(const ::tensorflow::Scope& |
2899 | scope, ::tensorflow::Input |
2900 | input_dataset, |
2901 | ::tensorflow::InputList |
2902 | other_arguments, |
2903 | ::tensorflow::Input |
2904 | cycle_length, |
2905 | ::tensorflow::Input |
2906 | block_length, |
2907 | ::tensorflow::Input |
2908 | sloppy, |
2909 | ::tensorflow::Input |
2910 | buffer_output_elements, |
2911 | ::tensorflow::Input |
2912 | prefetch_input_elements, |
2913 | const NameAttrList& f, |
2914 | const DataTypeSlice& |
2915 | output_types, const |
2916 | gtl::ArraySlice<PartialTensorShape>& |
2917 | output_shapes) |
2918 | : ParallelInterleaveDataset(scope, input_dataset, other_arguments, cycle_length, block_length, sloppy, buffer_output_elements, prefetch_input_elements, f, output_types, output_shapes, ParallelInterleaveDataset::Attrs()) {} |
2919 | |
2920 | ParseExampleDataset::ParseExampleDataset(const ::tensorflow::Scope& scope, |
2921 | ::tensorflow::Input input_dataset, |
2922 | ::tensorflow::Input |
2923 | num_parallel_calls, |
2924 | ::tensorflow::InputList |
2925 | dense_defaults, const |
2926 | gtl::ArraySlice<::tensorflow::tstring>& |
2927 | sparse_keys, const |
2928 | gtl::ArraySlice<::tensorflow::tstring>& |
2929 | dense_keys, const DataTypeSlice& |
2930 | sparse_types, const |
2931 | gtl::ArraySlice<PartialTensorShape>& |
2932 | dense_shapes, const DataTypeSlice& |
2933 | output_types, const |
2934 | gtl::ArraySlice<PartialTensorShape>& |
2935 | output_shapes, const |
2936 | ParseExampleDataset::Attrs& attrs) { |
2937 | if (!scope.ok()) return; |
2938 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
2939 | if (!scope.ok()) return; |
2940 | auto _num_parallel_calls = ::tensorflow::ops::AsNodeOut(scope, num_parallel_calls); |
2941 | if (!scope.ok()) return; |
2942 | auto _dense_defaults = ::tensorflow::ops::AsNodeOutList(scope, dense_defaults); |
2943 | if (!scope.ok()) return; |
2944 | ::tensorflow::Node* ret; |
2945 | const auto unique_name = scope.GetUniqueNameForOp("ParseExampleDataset" ); |
2946 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ParseExampleDataset" ) |
2947 | .Input(_input_dataset) |
2948 | .Input(_num_parallel_calls) |
2949 | .Input(_dense_defaults) |
2950 | .Attr("sparse_keys" , sparse_keys) |
2951 | .Attr("dense_keys" , dense_keys) |
2952 | .Attr("sparse_types" , sparse_types) |
2953 | .Attr("dense_shapes" , dense_shapes) |
2954 | .Attr("output_types" , output_types) |
2955 | .Attr("output_shapes" , output_shapes) |
2956 | .Attr("sloppy" , attrs.sloppy_) |
2957 | .Attr("ragged_keys" , attrs.ragged_keys_) |
2958 | .Attr("ragged_value_types" , attrs.ragged_value_types_) |
2959 | .Attr("ragged_split_types" , attrs.ragged_split_types_) |
2960 | ; |
2961 | scope.UpdateBuilder(&builder); |
2962 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
2963 | if (!scope.ok()) return; |
2964 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
2965 | this->operation = Operation(ret); |
2966 | this->handle = Output(ret, 0); |
2967 | } |
2968 | |
2969 | ParseExampleDataset::ParseExampleDataset(const ::tensorflow::Scope& scope, |
2970 | ::tensorflow::Input input_dataset, |
2971 | ::tensorflow::Input |
2972 | num_parallel_calls, |
2973 | ::tensorflow::InputList |
2974 | dense_defaults, const |
2975 | gtl::ArraySlice<::tensorflow::tstring>& |
2976 | sparse_keys, const |
2977 | gtl::ArraySlice<::tensorflow::tstring>& |
2978 | dense_keys, const DataTypeSlice& |
2979 | sparse_types, const |
2980 | gtl::ArraySlice<PartialTensorShape>& |
2981 | dense_shapes, const DataTypeSlice& |
2982 | output_types, const |
2983 | gtl::ArraySlice<PartialTensorShape>& |
2984 | output_shapes) |
2985 | : ParseExampleDataset(scope, input_dataset, num_parallel_calls, dense_defaults, sparse_keys, dense_keys, sparse_types, dense_shapes, output_types, output_shapes, ParseExampleDataset::Attrs()) {} |
2986 | |
2987 | ParseExampleDatasetV2::ParseExampleDatasetV2(const ::tensorflow::Scope& scope, |
2988 | ::tensorflow::Input input_dataset, |
2989 | ::tensorflow::Input |
2990 | num_parallel_calls, |
2991 | ::tensorflow::InputList |
2992 | dense_defaults, const |
2993 | gtl::ArraySlice<::tensorflow::tstring>& |
2994 | sparse_keys, const |
2995 | gtl::ArraySlice<::tensorflow::tstring>& |
2996 | dense_keys, const DataTypeSlice& |
2997 | sparse_types, const |
2998 | gtl::ArraySlice<PartialTensorShape>& |
2999 | dense_shapes, const DataTypeSlice& |
3000 | output_types, const |
3001 | gtl::ArraySlice<PartialTensorShape>& |
3002 | output_shapes, const |
3003 | ParseExampleDatasetV2::Attrs& |
3004 | attrs) { |
3005 | if (!scope.ok()) return; |
3006 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3007 | if (!scope.ok()) return; |
3008 | auto _num_parallel_calls = ::tensorflow::ops::AsNodeOut(scope, num_parallel_calls); |
3009 | if (!scope.ok()) return; |
3010 | auto _dense_defaults = ::tensorflow::ops::AsNodeOutList(scope, dense_defaults); |
3011 | if (!scope.ok()) return; |
3012 | ::tensorflow::Node* ret; |
3013 | const auto unique_name = scope.GetUniqueNameForOp("ParseExampleDatasetV2" ); |
3014 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ParseExampleDatasetV2" ) |
3015 | .Input(_input_dataset) |
3016 | .Input(_num_parallel_calls) |
3017 | .Input(_dense_defaults) |
3018 | .Attr("sparse_keys" , sparse_keys) |
3019 | .Attr("dense_keys" , dense_keys) |
3020 | .Attr("sparse_types" , sparse_types) |
3021 | .Attr("dense_shapes" , dense_shapes) |
3022 | .Attr("output_types" , output_types) |
3023 | .Attr("output_shapes" , output_shapes) |
3024 | .Attr("deterministic" , attrs.deterministic_) |
3025 | .Attr("ragged_keys" , attrs.ragged_keys_) |
3026 | .Attr("ragged_value_types" , attrs.ragged_value_types_) |
3027 | .Attr("ragged_split_types" , attrs.ragged_split_types_) |
3028 | ; |
3029 | scope.UpdateBuilder(&builder); |
3030 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3031 | if (!scope.ok()) return; |
3032 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3033 | this->operation = Operation(ret); |
3034 | this->handle = Output(ret, 0); |
3035 | } |
3036 | |
3037 | ParseExampleDatasetV2::ParseExampleDatasetV2(const ::tensorflow::Scope& scope, |
3038 | ::tensorflow::Input input_dataset, |
3039 | ::tensorflow::Input |
3040 | num_parallel_calls, |
3041 | ::tensorflow::InputList |
3042 | dense_defaults, const |
3043 | gtl::ArraySlice<::tensorflow::tstring>& |
3044 | sparse_keys, const |
3045 | gtl::ArraySlice<::tensorflow::tstring>& |
3046 | dense_keys, const DataTypeSlice& |
3047 | sparse_types, const |
3048 | gtl::ArraySlice<PartialTensorShape>& |
3049 | dense_shapes, const DataTypeSlice& |
3050 | output_types, const |
3051 | gtl::ArraySlice<PartialTensorShape>& |
3052 | output_shapes) |
3053 | : ParseExampleDatasetV2(scope, input_dataset, num_parallel_calls, dense_defaults, sparse_keys, dense_keys, sparse_types, dense_shapes, output_types, output_shapes, ParseExampleDatasetV2::Attrs()) {} |
3054 | |
3055 | PrivateThreadPoolDataset::PrivateThreadPoolDataset(const ::tensorflow::Scope& |
3056 | scope, ::tensorflow::Input |
3057 | input_dataset, |
3058 | ::tensorflow::Input |
3059 | num_threads, const |
3060 | DataTypeSlice& output_types, |
3061 | const |
3062 | gtl::ArraySlice<PartialTensorShape>& |
3063 | output_shapes) { |
3064 | if (!scope.ok()) return; |
3065 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3066 | if (!scope.ok()) return; |
3067 | auto _num_threads = ::tensorflow::ops::AsNodeOut(scope, num_threads); |
3068 | if (!scope.ok()) return; |
3069 | ::tensorflow::Node* ret; |
3070 | const auto unique_name = scope.GetUniqueNameForOp("PrivateThreadPoolDataset" ); |
3071 | auto builder = ::tensorflow::NodeBuilder(unique_name, "PrivateThreadPoolDataset" ) |
3072 | .Input(_input_dataset) |
3073 | .Input(_num_threads) |
3074 | .Attr("output_types" , output_types) |
3075 | .Attr("output_shapes" , output_shapes) |
3076 | ; |
3077 | scope.UpdateBuilder(&builder); |
3078 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3079 | if (!scope.ok()) return; |
3080 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3081 | this->operation = Operation(ret); |
3082 | this->handle = Output(ret, 0); |
3083 | } |
3084 | |
3085 | RandomDataset::RandomDataset(const ::tensorflow::Scope& scope, |
3086 | ::tensorflow::Input seed, ::tensorflow::Input |
3087 | seed2, const DataTypeSlice& output_types, const |
3088 | gtl::ArraySlice<PartialTensorShape>& |
3089 | output_shapes, const RandomDataset::Attrs& attrs) { |
3090 | if (!scope.ok()) return; |
3091 | auto _seed = ::tensorflow::ops::AsNodeOut(scope, seed); |
3092 | if (!scope.ok()) return; |
3093 | auto _seed2 = ::tensorflow::ops::AsNodeOut(scope, seed2); |
3094 | if (!scope.ok()) return; |
3095 | ::tensorflow::Node* ret; |
3096 | const auto unique_name = scope.GetUniqueNameForOp("RandomDataset" ); |
3097 | auto builder = ::tensorflow::NodeBuilder(unique_name, "RandomDataset" ) |
3098 | .Input(_seed) |
3099 | .Input(_seed2) |
3100 | .Attr("output_types" , output_types) |
3101 | .Attr("output_shapes" , output_shapes) |
3102 | .Attr("metadata" , attrs.metadata_) |
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->handle = Output(ret, 0); |
3110 | } |
3111 | |
3112 | RandomDataset::RandomDataset(const ::tensorflow::Scope& scope, |
3113 | ::tensorflow::Input seed, ::tensorflow::Input |
3114 | seed2, const DataTypeSlice& output_types, const |
3115 | gtl::ArraySlice<PartialTensorShape>& |
3116 | output_shapes) |
3117 | : RandomDataset(scope, seed, seed2, output_types, output_shapes, RandomDataset::Attrs()) {} |
3118 | |
3119 | RebatchDataset::RebatchDataset(const ::tensorflow::Scope& scope, |
3120 | ::tensorflow::Input input_dataset, |
3121 | ::tensorflow::Input num_replicas, const |
3122 | DataTypeSlice& output_types, const |
3123 | gtl::ArraySlice<PartialTensorShape>& |
3124 | output_shapes, const RebatchDataset::Attrs& |
3125 | attrs) { |
3126 | if (!scope.ok()) return; |
3127 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3128 | if (!scope.ok()) return; |
3129 | auto _num_replicas = ::tensorflow::ops::AsNodeOut(scope, num_replicas); |
3130 | if (!scope.ok()) return; |
3131 | ::tensorflow::Node* ret; |
3132 | const auto unique_name = scope.GetUniqueNameForOp("RebatchDataset" ); |
3133 | auto builder = ::tensorflow::NodeBuilder(unique_name, "RebatchDataset" ) |
3134 | .Input(_input_dataset) |
3135 | .Input(_num_replicas) |
3136 | .Attr("output_types" , output_types) |
3137 | .Attr("output_shapes" , output_shapes) |
3138 | .Attr("use_fallback" , attrs.use_fallback_) |
3139 | ; |
3140 | scope.UpdateBuilder(&builder); |
3141 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3142 | if (!scope.ok()) return; |
3143 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3144 | this->operation = Operation(ret); |
3145 | this->handle = Output(ret, 0); |
3146 | } |
3147 | |
3148 | RebatchDataset::RebatchDataset(const ::tensorflow::Scope& scope, |
3149 | ::tensorflow::Input input_dataset, |
3150 | ::tensorflow::Input num_replicas, const |
3151 | DataTypeSlice& output_types, const |
3152 | gtl::ArraySlice<PartialTensorShape>& |
3153 | output_shapes) |
3154 | : RebatchDataset(scope, input_dataset, num_replicas, output_types, output_shapes, RebatchDataset::Attrs()) {} |
3155 | |
3156 | RebatchDatasetV2::RebatchDatasetV2(const ::tensorflow::Scope& scope, |
3157 | ::tensorflow::Input input_dataset, |
3158 | ::tensorflow::Input batch_sizes, |
3159 | ::tensorflow::Input drop_remainder, const |
3160 | DataTypeSlice& output_types, const |
3161 | gtl::ArraySlice<PartialTensorShape>& |
3162 | output_shapes) { |
3163 | if (!scope.ok()) return; |
3164 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3165 | if (!scope.ok()) return; |
3166 | auto _batch_sizes = ::tensorflow::ops::AsNodeOut(scope, batch_sizes); |
3167 | if (!scope.ok()) return; |
3168 | auto _drop_remainder = ::tensorflow::ops::AsNodeOut(scope, drop_remainder); |
3169 | if (!scope.ok()) return; |
3170 | ::tensorflow::Node* ret; |
3171 | const auto unique_name = scope.GetUniqueNameForOp("RebatchDatasetV2" ); |
3172 | auto builder = ::tensorflow::NodeBuilder(unique_name, "RebatchDatasetV2" ) |
3173 | .Input(_input_dataset) |
3174 | .Input(_batch_sizes) |
3175 | .Input(_drop_remainder) |
3176 | .Attr("output_types" , output_types) |
3177 | .Attr("output_shapes" , output_shapes) |
3178 | ; |
3179 | scope.UpdateBuilder(&builder); |
3180 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3181 | if (!scope.ok()) return; |
3182 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3183 | this->operation = Operation(ret); |
3184 | this->handle = Output(ret, 0); |
3185 | } |
3186 | |
3187 | RegisterDataset::RegisterDataset(const ::tensorflow::Scope& scope, |
3188 | ::tensorflow::Input dataset, |
3189 | ::tensorflow::Input address, |
3190 | ::tensorflow::Input protocol, int64 |
3191 | external_state_policy, const |
3192 | RegisterDataset::Attrs& attrs) { |
3193 | if (!scope.ok()) return; |
3194 | auto _dataset = ::tensorflow::ops::AsNodeOut(scope, dataset); |
3195 | if (!scope.ok()) return; |
3196 | auto _address = ::tensorflow::ops::AsNodeOut(scope, address); |
3197 | if (!scope.ok()) return; |
3198 | auto _protocol = ::tensorflow::ops::AsNodeOut(scope, protocol); |
3199 | if (!scope.ok()) return; |
3200 | ::tensorflow::Node* ret; |
3201 | const auto unique_name = scope.GetUniqueNameForOp("RegisterDataset" ); |
3202 | auto builder = ::tensorflow::NodeBuilder(unique_name, "RegisterDataset" ) |
3203 | .Input(_dataset) |
3204 | .Input(_address) |
3205 | .Input(_protocol) |
3206 | .Attr("external_state_policy" , external_state_policy) |
3207 | .Attr("element_spec" , attrs.element_spec_) |
3208 | .Attr("metadata" , attrs.metadata_) |
3209 | ; |
3210 | scope.UpdateBuilder(&builder); |
3211 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3212 | if (!scope.ok()) return; |
3213 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3214 | this->operation = Operation(ret); |
3215 | this->dataset_id = Output(ret, 0); |
3216 | } |
3217 | |
3218 | RegisterDataset::RegisterDataset(const ::tensorflow::Scope& scope, |
3219 | ::tensorflow::Input dataset, |
3220 | ::tensorflow::Input address, |
3221 | ::tensorflow::Input protocol, int64 |
3222 | external_state_policy) |
3223 | : RegisterDataset(scope, dataset, address, protocol, external_state_policy, RegisterDataset::Attrs()) {} |
3224 | |
3225 | RegisterDatasetV2::RegisterDatasetV2(const ::tensorflow::Scope& scope, |
3226 | ::tensorflow::Input dataset, |
3227 | ::tensorflow::Input address, |
3228 | ::tensorflow::Input protocol, int64 |
3229 | external_state_policy, const |
3230 | RegisterDatasetV2::Attrs& attrs) { |
3231 | if (!scope.ok()) return; |
3232 | auto _dataset = ::tensorflow::ops::AsNodeOut(scope, dataset); |
3233 | if (!scope.ok()) return; |
3234 | auto _address = ::tensorflow::ops::AsNodeOut(scope, address); |
3235 | if (!scope.ok()) return; |
3236 | auto _protocol = ::tensorflow::ops::AsNodeOut(scope, protocol); |
3237 | if (!scope.ok()) return; |
3238 | ::tensorflow::Node* ret; |
3239 | const auto unique_name = scope.GetUniqueNameForOp("RegisterDatasetV2" ); |
3240 | auto builder = ::tensorflow::NodeBuilder(unique_name, "RegisterDatasetV2" ) |
3241 | .Input(_dataset) |
3242 | .Input(_address) |
3243 | .Input(_protocol) |
3244 | .Attr("external_state_policy" , external_state_policy) |
3245 | .Attr("element_spec" , attrs.element_spec_) |
3246 | .Attr("requested_dataset_id" , attrs.requested_dataset_id_) |
3247 | .Attr("metadata" , attrs.metadata_) |
3248 | ; |
3249 | scope.UpdateBuilder(&builder); |
3250 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3251 | if (!scope.ok()) return; |
3252 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3253 | this->operation = Operation(ret); |
3254 | this->dataset_id = Output(ret, 0); |
3255 | } |
3256 | |
3257 | RegisterDatasetV2::RegisterDatasetV2(const ::tensorflow::Scope& scope, |
3258 | ::tensorflow::Input dataset, |
3259 | ::tensorflow::Input address, |
3260 | ::tensorflow::Input protocol, int64 |
3261 | external_state_policy) |
3262 | : RegisterDatasetV2(scope, dataset, address, protocol, external_state_policy, RegisterDatasetV2::Attrs()) {} |
3263 | |
3264 | SamplingDataset::SamplingDataset(const ::tensorflow::Scope& scope, |
3265 | ::tensorflow::Input input_dataset, |
3266 | ::tensorflow::Input rate, ::tensorflow::Input |
3267 | seed, ::tensorflow::Input seed2, const |
3268 | DataTypeSlice& output_types, const |
3269 | gtl::ArraySlice<PartialTensorShape>& |
3270 | output_shapes) { |
3271 | if (!scope.ok()) return; |
3272 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3273 | if (!scope.ok()) return; |
3274 | auto _rate = ::tensorflow::ops::AsNodeOut(scope, rate); |
3275 | if (!scope.ok()) return; |
3276 | auto _seed = ::tensorflow::ops::AsNodeOut(scope, seed); |
3277 | if (!scope.ok()) return; |
3278 | auto _seed2 = ::tensorflow::ops::AsNodeOut(scope, seed2); |
3279 | if (!scope.ok()) return; |
3280 | ::tensorflow::Node* ret; |
3281 | const auto unique_name = scope.GetUniqueNameForOp("SamplingDataset" ); |
3282 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SamplingDataset" ) |
3283 | .Input(_input_dataset) |
3284 | .Input(_rate) |
3285 | .Input(_seed) |
3286 | .Input(_seed2) |
3287 | .Attr("output_types" , output_types) |
3288 | .Attr("output_shapes" , output_shapes) |
3289 | ; |
3290 | scope.UpdateBuilder(&builder); |
3291 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3292 | if (!scope.ok()) return; |
3293 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3294 | this->operation = Operation(ret); |
3295 | this->handle = Output(ret, 0); |
3296 | } |
3297 | |
3298 | SaveDataset::SaveDataset(const ::tensorflow::Scope& scope, ::tensorflow::Input |
3299 | input_dataset, ::tensorflow::Input path, |
3300 | ::tensorflow::InputList shard_func_other_args, const |
3301 | NameAttrList& shard_func, const SaveDataset::Attrs& |
3302 | attrs) { |
3303 | if (!scope.ok()) return; |
3304 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3305 | if (!scope.ok()) return; |
3306 | auto _path = ::tensorflow::ops::AsNodeOut(scope, path); |
3307 | if (!scope.ok()) return; |
3308 | auto _shard_func_other_args = ::tensorflow::ops::AsNodeOutList(scope, shard_func_other_args); |
3309 | if (!scope.ok()) return; |
3310 | ::tensorflow::Node* ret; |
3311 | const auto unique_name = scope.GetUniqueNameForOp("SaveDataset" ); |
3312 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SaveDataset" ) |
3313 | .Input(_input_dataset) |
3314 | .Input(_path) |
3315 | .Input(_shard_func_other_args) |
3316 | .Attr("compression" , attrs.compression_) |
3317 | .Attr("shard_func" , shard_func) |
3318 | .Attr("use_shard_func" , attrs.use_shard_func_) |
3319 | ; |
3320 | scope.UpdateBuilder(&builder); |
3321 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3322 | if (!scope.ok()) return; |
3323 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3324 | this->operation = Operation(ret); |
3325 | return; |
3326 | } |
3327 | |
3328 | SaveDataset::SaveDataset(const ::tensorflow::Scope& scope, ::tensorflow::Input |
3329 | input_dataset, ::tensorflow::Input path, |
3330 | ::tensorflow::InputList shard_func_other_args, const |
3331 | NameAttrList& shard_func) |
3332 | : SaveDataset(scope, input_dataset, path, shard_func_other_args, shard_func, SaveDataset::Attrs()) {} |
3333 | |
3334 | SaveDatasetV2::SaveDatasetV2(const ::tensorflow::Scope& scope, |
3335 | ::tensorflow::Input input_dataset, |
3336 | ::tensorflow::Input path, ::tensorflow::InputList |
3337 | shard_func_other_args, const NameAttrList& |
3338 | shard_func, const DataTypeSlice& output_types, |
3339 | const gtl::ArraySlice<PartialTensorShape>& |
3340 | output_shapes, const SaveDatasetV2::Attrs& attrs) { |
3341 | if (!scope.ok()) return; |
3342 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3343 | if (!scope.ok()) return; |
3344 | auto _path = ::tensorflow::ops::AsNodeOut(scope, path); |
3345 | if (!scope.ok()) return; |
3346 | auto _shard_func_other_args = ::tensorflow::ops::AsNodeOutList(scope, shard_func_other_args); |
3347 | if (!scope.ok()) return; |
3348 | ::tensorflow::Node* ret; |
3349 | const auto unique_name = scope.GetUniqueNameForOp("SaveDatasetV2" ); |
3350 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SaveDatasetV2" ) |
3351 | .Input(_input_dataset) |
3352 | .Input(_path) |
3353 | .Input(_shard_func_other_args) |
3354 | .Attr("compression" , attrs.compression_) |
3355 | .Attr("shard_func" , shard_func) |
3356 | .Attr("use_shard_func" , attrs.use_shard_func_) |
3357 | .Attr("output_types" , output_types) |
3358 | .Attr("output_shapes" , output_shapes) |
3359 | ; |
3360 | scope.UpdateBuilder(&builder); |
3361 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3362 | if (!scope.ok()) return; |
3363 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3364 | this->operation = Operation(ret); |
3365 | this->handle = Output(ret, 0); |
3366 | } |
3367 | |
3368 | SaveDatasetV2::SaveDatasetV2(const ::tensorflow::Scope& scope, |
3369 | ::tensorflow::Input input_dataset, |
3370 | ::tensorflow::Input path, ::tensorflow::InputList |
3371 | shard_func_other_args, const NameAttrList& |
3372 | shard_func, const DataTypeSlice& output_types, |
3373 | const gtl::ArraySlice<PartialTensorShape>& |
3374 | output_shapes) |
3375 | : SaveDatasetV2(scope, input_dataset, path, shard_func_other_args, shard_func, output_types, output_shapes, SaveDatasetV2::Attrs()) {} |
3376 | |
3377 | ScanDataset::ScanDataset(const ::tensorflow::Scope& scope, ::tensorflow::Input |
3378 | input_dataset, ::tensorflow::InputList initial_state, |
3379 | ::tensorflow::InputList other_arguments, const |
3380 | NameAttrList& f, const DataTypeSlice& output_types, |
3381 | const gtl::ArraySlice<PartialTensorShape>& |
3382 | output_shapes, const ScanDataset::Attrs& attrs) { |
3383 | if (!scope.ok()) return; |
3384 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3385 | if (!scope.ok()) return; |
3386 | auto _initial_state = ::tensorflow::ops::AsNodeOutList(scope, initial_state); |
3387 | if (!scope.ok()) return; |
3388 | auto _other_arguments = ::tensorflow::ops::AsNodeOutList(scope, other_arguments); |
3389 | if (!scope.ok()) return; |
3390 | ::tensorflow::Node* ret; |
3391 | const auto unique_name = scope.GetUniqueNameForOp("ScanDataset" ); |
3392 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ScanDataset" ) |
3393 | .Input(_input_dataset) |
3394 | .Input(_initial_state) |
3395 | .Input(_other_arguments) |
3396 | .Attr("f" , f) |
3397 | .Attr("output_types" , output_types) |
3398 | .Attr("output_shapes" , output_shapes) |
3399 | .Attr("preserve_cardinality" , attrs.preserve_cardinality_) |
3400 | .Attr("use_default_device" , attrs.use_default_device_) |
3401 | .Attr("metadata" , attrs.metadata_) |
3402 | ; |
3403 | scope.UpdateBuilder(&builder); |
3404 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3405 | if (!scope.ok()) return; |
3406 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3407 | this->operation = Operation(ret); |
3408 | this->handle = Output(ret, 0); |
3409 | } |
3410 | |
3411 | ScanDataset::ScanDataset(const ::tensorflow::Scope& scope, ::tensorflow::Input |
3412 | input_dataset, ::tensorflow::InputList initial_state, |
3413 | ::tensorflow::InputList other_arguments, const |
3414 | NameAttrList& f, const DataTypeSlice& output_types, |
3415 | const gtl::ArraySlice<PartialTensorShape>& |
3416 | output_shapes) |
3417 | : ScanDataset(scope, input_dataset, initial_state, other_arguments, f, output_types, output_shapes, ScanDataset::Attrs()) {} |
3418 | |
3419 | SetStatsAggregatorDataset::SetStatsAggregatorDataset(const ::tensorflow::Scope& |
3420 | scope, ::tensorflow::Input |
3421 | input_dataset, |
3422 | ::tensorflow::Input |
3423 | stats_aggregator, |
3424 | ::tensorflow::Input tag, |
3425 | ::tensorflow::Input |
3426 | counter_prefix, const |
3427 | DataTypeSlice& |
3428 | output_types, const |
3429 | gtl::ArraySlice<PartialTensorShape>& |
3430 | output_shapes) { |
3431 | if (!scope.ok()) return; |
3432 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3433 | if (!scope.ok()) return; |
3434 | auto _stats_aggregator = ::tensorflow::ops::AsNodeOut(scope, stats_aggregator); |
3435 | if (!scope.ok()) return; |
3436 | auto _tag = ::tensorflow::ops::AsNodeOut(scope, tag); |
3437 | if (!scope.ok()) return; |
3438 | auto _counter_prefix = ::tensorflow::ops::AsNodeOut(scope, counter_prefix); |
3439 | if (!scope.ok()) return; |
3440 | ::tensorflow::Node* ret; |
3441 | const auto unique_name = scope.GetUniqueNameForOp("SetStatsAggregatorDataset" ); |
3442 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SetStatsAggregatorDataset" ) |
3443 | .Input(_input_dataset) |
3444 | .Input(_stats_aggregator) |
3445 | .Input(_tag) |
3446 | .Input(_counter_prefix) |
3447 | .Attr("output_types" , output_types) |
3448 | .Attr("output_shapes" , output_shapes) |
3449 | ; |
3450 | scope.UpdateBuilder(&builder); |
3451 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3452 | if (!scope.ok()) return; |
3453 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3454 | this->operation = Operation(ret); |
3455 | this->handle = Output(ret, 0); |
3456 | } |
3457 | |
3458 | SleepDataset::SleepDataset(const ::tensorflow::Scope& scope, |
3459 | ::tensorflow::Input input_dataset, |
3460 | ::tensorflow::Input sleep_microseconds, const |
3461 | DataTypeSlice& output_types, const |
3462 | gtl::ArraySlice<PartialTensorShape>& output_shapes) { |
3463 | if (!scope.ok()) return; |
3464 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3465 | if (!scope.ok()) return; |
3466 | auto _sleep_microseconds = ::tensorflow::ops::AsNodeOut(scope, sleep_microseconds); |
3467 | if (!scope.ok()) return; |
3468 | ::tensorflow::Node* ret; |
3469 | const auto unique_name = scope.GetUniqueNameForOp("SleepDataset" ); |
3470 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SleepDataset" ) |
3471 | .Input(_input_dataset) |
3472 | .Input(_sleep_microseconds) |
3473 | .Attr("output_types" , output_types) |
3474 | .Attr("output_shapes" , output_shapes) |
3475 | ; |
3476 | scope.UpdateBuilder(&builder); |
3477 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3478 | if (!scope.ok()) return; |
3479 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3480 | this->operation = Operation(ret); |
3481 | this->handle = Output(ret, 0); |
3482 | } |
3483 | |
3484 | SlidingWindowDataset::SlidingWindowDataset(const ::tensorflow::Scope& scope, |
3485 | ::tensorflow::Input input_dataset, |
3486 | ::tensorflow::Input window_size, |
3487 | ::tensorflow::Input window_shift, |
3488 | ::tensorflow::Input window_stride, |
3489 | const DataTypeSlice& output_types, |
3490 | const |
3491 | gtl::ArraySlice<PartialTensorShape>& |
3492 | output_shapes, const |
3493 | SlidingWindowDataset::Attrs& attrs) { |
3494 | if (!scope.ok()) return; |
3495 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3496 | if (!scope.ok()) return; |
3497 | auto _window_size = ::tensorflow::ops::AsNodeOut(scope, window_size); |
3498 | if (!scope.ok()) return; |
3499 | auto _window_shift = ::tensorflow::ops::AsNodeOut(scope, window_shift); |
3500 | if (!scope.ok()) return; |
3501 | auto _window_stride = ::tensorflow::ops::AsNodeOut(scope, window_stride); |
3502 | if (!scope.ok()) return; |
3503 | ::tensorflow::Node* ret; |
3504 | const auto unique_name = scope.GetUniqueNameForOp("SlidingWindowDataset" ); |
3505 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SlidingWindowDataset" ) |
3506 | .Input(_input_dataset) |
3507 | .Input(_window_size) |
3508 | .Input(_window_shift) |
3509 | .Input(_window_stride) |
3510 | .Attr("drop_remainder" , attrs.drop_remainder_) |
3511 | .Attr("output_types" , output_types) |
3512 | .Attr("output_shapes" , output_shapes) |
3513 | ; |
3514 | scope.UpdateBuilder(&builder); |
3515 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3516 | if (!scope.ok()) return; |
3517 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3518 | this->operation = Operation(ret); |
3519 | this->handle = Output(ret, 0); |
3520 | } |
3521 | |
3522 | SlidingWindowDataset::SlidingWindowDataset(const ::tensorflow::Scope& scope, |
3523 | ::tensorflow::Input input_dataset, |
3524 | ::tensorflow::Input window_size, |
3525 | ::tensorflow::Input window_shift, |
3526 | ::tensorflow::Input window_stride, |
3527 | const DataTypeSlice& output_types, |
3528 | const |
3529 | gtl::ArraySlice<PartialTensorShape>& |
3530 | output_shapes) |
3531 | : SlidingWindowDataset(scope, input_dataset, window_size, window_shift, window_stride, output_types, output_shapes, SlidingWindowDataset::Attrs()) {} |
3532 | |
3533 | SnapshotDataset::SnapshotDataset(const ::tensorflow::Scope& scope, |
3534 | ::tensorflow::Input input_dataset, |
3535 | ::tensorflow::Input path, const DataTypeSlice& |
3536 | output_types, const |
3537 | gtl::ArraySlice<PartialTensorShape>& |
3538 | output_shapes, const SnapshotDataset::Attrs& |
3539 | attrs) { |
3540 | if (!scope.ok()) return; |
3541 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3542 | if (!scope.ok()) return; |
3543 | auto _path = ::tensorflow::ops::AsNodeOut(scope, path); |
3544 | if (!scope.ok()) return; |
3545 | ::tensorflow::Node* ret; |
3546 | const auto unique_name = scope.GetUniqueNameForOp("SnapshotDataset" ); |
3547 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SnapshotDataset" ) |
3548 | .Input(_input_dataset) |
3549 | .Input(_path) |
3550 | .Attr("output_types" , output_types) |
3551 | .Attr("output_shapes" , output_shapes) |
3552 | .Attr("compression" , attrs.compression_) |
3553 | .Attr("reader_path_prefix" , attrs.reader_path_prefix_) |
3554 | .Attr("writer_path_prefix" , attrs.writer_path_prefix_) |
3555 | .Attr("shard_size_bytes" , attrs.shard_size_bytes_) |
3556 | .Attr("pending_snapshot_expiry_seconds" , attrs.pending_snapshot_expiry_seconds_) |
3557 | .Attr("num_reader_threads" , attrs.num_reader_threads_) |
3558 | .Attr("reader_buffer_size" , attrs.reader_buffer_size_) |
3559 | .Attr("num_writer_threads" , attrs.num_writer_threads_) |
3560 | .Attr("writer_buffer_size" , attrs.writer_buffer_size_) |
3561 | .Attr("shuffle_on_read" , attrs.shuffle_on_read_) |
3562 | .Attr("seed" , attrs.seed_) |
3563 | .Attr("seed2" , attrs.seed2_) |
3564 | .Attr("mode" , attrs.mode_) |
3565 | .Attr("snapshot_name" , attrs.snapshot_name_) |
3566 | ; |
3567 | scope.UpdateBuilder(&builder); |
3568 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3569 | if (!scope.ok()) return; |
3570 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3571 | this->operation = Operation(ret); |
3572 | this->handle = Output(ret, 0); |
3573 | } |
3574 | |
3575 | SnapshotDataset::SnapshotDataset(const ::tensorflow::Scope& scope, |
3576 | ::tensorflow::Input input_dataset, |
3577 | ::tensorflow::Input path, const DataTypeSlice& |
3578 | output_types, const |
3579 | gtl::ArraySlice<PartialTensorShape>& |
3580 | output_shapes) |
3581 | : SnapshotDataset(scope, input_dataset, path, output_types, output_shapes, SnapshotDataset::Attrs()) {} |
3582 | |
3583 | SnapshotDatasetReader::SnapshotDatasetReader(const ::tensorflow::Scope& scope, |
3584 | ::tensorflow::Input shard_dir, |
3585 | ::tensorflow::Input start_index, |
3586 | const DataTypeSlice& output_types, |
3587 | const |
3588 | gtl::ArraySlice<PartialTensorShape>& |
3589 | output_shapes, int64 version, |
3590 | const |
3591 | SnapshotDatasetReader::Attrs& |
3592 | attrs) { |
3593 | if (!scope.ok()) return; |
3594 | auto _shard_dir = ::tensorflow::ops::AsNodeOut(scope, shard_dir); |
3595 | if (!scope.ok()) return; |
3596 | auto _start_index = ::tensorflow::ops::AsNodeOut(scope, start_index); |
3597 | if (!scope.ok()) return; |
3598 | ::tensorflow::Node* ret; |
3599 | const auto unique_name = scope.GetUniqueNameForOp("SnapshotDatasetReader" ); |
3600 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SnapshotDatasetReader" ) |
3601 | .Input(_shard_dir) |
3602 | .Input(_start_index) |
3603 | .Attr("output_types" , output_types) |
3604 | .Attr("output_shapes" , output_shapes) |
3605 | .Attr("compression" , attrs.compression_) |
3606 | .Attr("version" , version) |
3607 | ; |
3608 | scope.UpdateBuilder(&builder); |
3609 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3610 | if (!scope.ok()) return; |
3611 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3612 | this->operation = Operation(ret); |
3613 | this->handle = Output(ret, 0); |
3614 | } |
3615 | |
3616 | SnapshotDatasetReader::SnapshotDatasetReader(const ::tensorflow::Scope& scope, |
3617 | ::tensorflow::Input shard_dir, |
3618 | ::tensorflow::Input start_index, |
3619 | const DataTypeSlice& output_types, |
3620 | const |
3621 | gtl::ArraySlice<PartialTensorShape>& |
3622 | output_shapes, int64 version) |
3623 | : SnapshotDatasetReader(scope, shard_dir, start_index, output_types, output_shapes, version, SnapshotDatasetReader::Attrs()) {} |
3624 | |
3625 | SnapshotDatasetV2::SnapshotDatasetV2(const ::tensorflow::Scope& scope, |
3626 | ::tensorflow::Input input_dataset, |
3627 | ::tensorflow::Input path, |
3628 | ::tensorflow::InputList |
3629 | reader_func_other_args, |
3630 | ::tensorflow::InputList |
3631 | shard_func_other_args, const |
3632 | DataTypeSlice& output_types, const |
3633 | gtl::ArraySlice<PartialTensorShape>& |
3634 | output_shapes, const NameAttrList& |
3635 | reader_func, const NameAttrList& |
3636 | shard_func, const |
3637 | SnapshotDatasetV2::Attrs& attrs) { |
3638 | if (!scope.ok()) return; |
3639 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3640 | if (!scope.ok()) return; |
3641 | auto _path = ::tensorflow::ops::AsNodeOut(scope, path); |
3642 | if (!scope.ok()) return; |
3643 | auto _reader_func_other_args = ::tensorflow::ops::AsNodeOutList(scope, reader_func_other_args); |
3644 | if (!scope.ok()) return; |
3645 | auto _shard_func_other_args = ::tensorflow::ops::AsNodeOutList(scope, shard_func_other_args); |
3646 | if (!scope.ok()) return; |
3647 | ::tensorflow::Node* ret; |
3648 | const auto unique_name = scope.GetUniqueNameForOp("SnapshotDatasetV2" ); |
3649 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SnapshotDatasetV2" ) |
3650 | .Input(_input_dataset) |
3651 | .Input(_path) |
3652 | .Input(_reader_func_other_args) |
3653 | .Input(_shard_func_other_args) |
3654 | .Attr("output_types" , output_types) |
3655 | .Attr("output_shapes" , output_shapes) |
3656 | .Attr("compression" , attrs.compression_) |
3657 | .Attr("reader_prefix" , attrs.reader_prefix_) |
3658 | .Attr("writer_prefix" , attrs.writer_prefix_) |
3659 | .Attr("hash_valid" , attrs.hash_valid_) |
3660 | .Attr("hash" , attrs.hash_) |
3661 | .Attr("reader_func" , reader_func) |
3662 | .Attr("shard_func" , shard_func) |
3663 | .Attr("metadata" , attrs.metadata_) |
3664 | ; |
3665 | scope.UpdateBuilder(&builder); |
3666 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3667 | if (!scope.ok()) return; |
3668 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3669 | this->operation = Operation(ret); |
3670 | this->handle = Output(ret, 0); |
3671 | } |
3672 | |
3673 | SnapshotDatasetV2::SnapshotDatasetV2(const ::tensorflow::Scope& scope, |
3674 | ::tensorflow::Input input_dataset, |
3675 | ::tensorflow::Input path, |
3676 | ::tensorflow::InputList |
3677 | reader_func_other_args, |
3678 | ::tensorflow::InputList |
3679 | shard_func_other_args, const |
3680 | DataTypeSlice& output_types, const |
3681 | gtl::ArraySlice<PartialTensorShape>& |
3682 | output_shapes, const NameAttrList& |
3683 | reader_func, const NameAttrList& |
3684 | shard_func) |
3685 | : SnapshotDatasetV2(scope, input_dataset, path, reader_func_other_args, shard_func_other_args, output_types, output_shapes, reader_func, shard_func, SnapshotDatasetV2::Attrs()) {} |
3686 | |
3687 | SnapshotNestedDatasetReader::SnapshotNestedDatasetReader(const |
3688 | ::tensorflow::Scope& |
3689 | scope, |
3690 | ::tensorflow::InputList |
3691 | inputs, const |
3692 | DataTypeSlice& |
3693 | output_types, const |
3694 | gtl::ArraySlice<PartialTensorShape>& |
3695 | output_shapes) { |
3696 | if (!scope.ok()) return; |
3697 | auto _inputs = ::tensorflow::ops::AsNodeOutList(scope, inputs); |
3698 | if (!scope.ok()) return; |
3699 | ::tensorflow::Node* ret; |
3700 | const auto unique_name = scope.GetUniqueNameForOp("SnapshotNestedDatasetReader" ); |
3701 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SnapshotNestedDatasetReader" ) |
3702 | .Input(_inputs) |
3703 | .Attr("output_types" , output_types) |
3704 | .Attr("output_shapes" , output_shapes) |
3705 | ; |
3706 | scope.UpdateBuilder(&builder); |
3707 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3708 | if (!scope.ok()) return; |
3709 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3710 | this->operation = Operation(ret); |
3711 | this->handle = Output(ret, 0); |
3712 | } |
3713 | |
3714 | SqlDataset::SqlDataset(const ::tensorflow::Scope& scope, ::tensorflow::Input |
3715 | driver_name, ::tensorflow::Input data_source_name, |
3716 | ::tensorflow::Input query, const DataTypeSlice& |
3717 | output_types, const gtl::ArraySlice<PartialTensorShape>& |
3718 | output_shapes) { |
3719 | if (!scope.ok()) return; |
3720 | auto _driver_name = ::tensorflow::ops::AsNodeOut(scope, driver_name); |
3721 | if (!scope.ok()) return; |
3722 | auto _data_source_name = ::tensorflow::ops::AsNodeOut(scope, data_source_name); |
3723 | if (!scope.ok()) return; |
3724 | auto _query = ::tensorflow::ops::AsNodeOut(scope, query); |
3725 | if (!scope.ok()) return; |
3726 | ::tensorflow::Node* ret; |
3727 | const auto unique_name = scope.GetUniqueNameForOp("SqlDataset" ); |
3728 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SqlDataset" ) |
3729 | .Input(_driver_name) |
3730 | .Input(_data_source_name) |
3731 | .Input(_query) |
3732 | .Attr("output_types" , output_types) |
3733 | .Attr("output_shapes" , output_shapes) |
3734 | ; |
3735 | scope.UpdateBuilder(&builder); |
3736 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3737 | if (!scope.ok()) return; |
3738 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3739 | this->operation = Operation(ret); |
3740 | this->handle = Output(ret, 0); |
3741 | } |
3742 | |
3743 | StatsAggregatorHandle::StatsAggregatorHandle(const ::tensorflow::Scope& scope, |
3744 | const |
3745 | StatsAggregatorHandle::Attrs& |
3746 | attrs) { |
3747 | if (!scope.ok()) return; |
3748 | ::tensorflow::Node* ret; |
3749 | const auto unique_name = scope.GetUniqueNameForOp("StatsAggregatorHandle" ); |
3750 | auto builder = ::tensorflow::NodeBuilder(unique_name, "StatsAggregatorHandle" ) |
3751 | .Attr("container" , attrs.container_) |
3752 | .Attr("shared_name" , attrs.shared_name_) |
3753 | ; |
3754 | scope.UpdateBuilder(&builder); |
3755 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3756 | if (!scope.ok()) return; |
3757 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3758 | this->operation = Operation(ret); |
3759 | this->handle = Output(ret, 0); |
3760 | } |
3761 | |
3762 | StatsAggregatorHandle::StatsAggregatorHandle(const ::tensorflow::Scope& scope) |
3763 | : StatsAggregatorHandle(scope, StatsAggregatorHandle::Attrs()) {} |
3764 | |
3765 | StatsAggregatorHandleV2::StatsAggregatorHandleV2(const ::tensorflow::Scope& |
3766 | scope, const |
3767 | StatsAggregatorHandleV2::Attrs& |
3768 | attrs) { |
3769 | if (!scope.ok()) return; |
3770 | ::tensorflow::Node* ret; |
3771 | const auto unique_name = scope.GetUniqueNameForOp("StatsAggregatorHandleV2" ); |
3772 | auto builder = ::tensorflow::NodeBuilder(unique_name, "StatsAggregatorHandleV2" ) |
3773 | .Attr("container" , attrs.container_) |
3774 | .Attr("shared_name" , attrs.shared_name_) |
3775 | ; |
3776 | scope.UpdateBuilder(&builder); |
3777 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3778 | if (!scope.ok()) return; |
3779 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3780 | this->operation = Operation(ret); |
3781 | this->handle = Output(ret, 0); |
3782 | } |
3783 | |
3784 | StatsAggregatorHandleV2::StatsAggregatorHandleV2(const ::tensorflow::Scope& |
3785 | scope) |
3786 | : StatsAggregatorHandleV2(scope, StatsAggregatorHandleV2::Attrs()) {} |
3787 | |
3788 | StatsAggregatorSetSummaryWriter::StatsAggregatorSetSummaryWriter(const |
3789 | ::tensorflow::Scope& |
3790 | scope, |
3791 | ::tensorflow::Input |
3792 | stats_aggregator, |
3793 | ::tensorflow::Input |
3794 | summary) { |
3795 | if (!scope.ok()) return; |
3796 | auto _stats_aggregator = ::tensorflow::ops::AsNodeOut(scope, stats_aggregator); |
3797 | if (!scope.ok()) return; |
3798 | auto _summary = ::tensorflow::ops::AsNodeOut(scope, summary); |
3799 | if (!scope.ok()) return; |
3800 | ::tensorflow::Node* ret; |
3801 | const auto unique_name = scope.GetUniqueNameForOp("StatsAggregatorSetSummaryWriter" ); |
3802 | auto builder = ::tensorflow::NodeBuilder(unique_name, "StatsAggregatorSetSummaryWriter" ) |
3803 | .Input(_stats_aggregator) |
3804 | .Input(_summary) |
3805 | ; |
3806 | scope.UpdateBuilder(&builder); |
3807 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3808 | if (!scope.ok()) return; |
3809 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3810 | this->operation = Operation(ret); |
3811 | return; |
3812 | } |
3813 | |
3814 | StatsAggregatorSummary::StatsAggregatorSummary(const ::tensorflow::Scope& |
3815 | scope, ::tensorflow::Input |
3816 | iterator) { |
3817 | if (!scope.ok()) return; |
3818 | auto _iterator = ::tensorflow::ops::AsNodeOut(scope, iterator); |
3819 | if (!scope.ok()) return; |
3820 | ::tensorflow::Node* ret; |
3821 | const auto unique_name = scope.GetUniqueNameForOp("StatsAggregatorSummary" ); |
3822 | auto builder = ::tensorflow::NodeBuilder(unique_name, "StatsAggregatorSummary" ) |
3823 | .Input(_iterator) |
3824 | ; |
3825 | scope.UpdateBuilder(&builder); |
3826 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3827 | if (!scope.ok()) return; |
3828 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3829 | this->operation = Operation(ret); |
3830 | this->summary = Output(ret, 0); |
3831 | } |
3832 | |
3833 | TakeWhileDataset::TakeWhileDataset(const ::tensorflow::Scope& scope, |
3834 | ::tensorflow::Input input_dataset, |
3835 | ::tensorflow::InputList other_arguments, |
3836 | const NameAttrList& predicate, const |
3837 | DataTypeSlice& output_types, const |
3838 | gtl::ArraySlice<PartialTensorShape>& |
3839 | output_shapes, const |
3840 | TakeWhileDataset::Attrs& attrs) { |
3841 | if (!scope.ok()) return; |
3842 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3843 | if (!scope.ok()) return; |
3844 | auto _other_arguments = ::tensorflow::ops::AsNodeOutList(scope, other_arguments); |
3845 | if (!scope.ok()) return; |
3846 | ::tensorflow::Node* ret; |
3847 | const auto unique_name = scope.GetUniqueNameForOp("TakeWhileDataset" ); |
3848 | auto builder = ::tensorflow::NodeBuilder(unique_name, "TakeWhileDataset" ) |
3849 | .Input(_input_dataset) |
3850 | .Input(_other_arguments) |
3851 | .Attr("predicate" , predicate) |
3852 | .Attr("output_types" , output_types) |
3853 | .Attr("output_shapes" , output_shapes) |
3854 | .Attr("metadata" , attrs.metadata_) |
3855 | ; |
3856 | scope.UpdateBuilder(&builder); |
3857 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3858 | if (!scope.ok()) return; |
3859 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3860 | this->operation = Operation(ret); |
3861 | this->handle = Output(ret, 0); |
3862 | } |
3863 | |
3864 | TakeWhileDataset::TakeWhileDataset(const ::tensorflow::Scope& scope, |
3865 | ::tensorflow::Input input_dataset, |
3866 | ::tensorflow::InputList other_arguments, |
3867 | const NameAttrList& predicate, const |
3868 | DataTypeSlice& output_types, const |
3869 | gtl::ArraySlice<PartialTensorShape>& |
3870 | output_shapes) |
3871 | : TakeWhileDataset(scope, input_dataset, other_arguments, predicate, output_types, output_shapes, TakeWhileDataset::Attrs()) {} |
3872 | |
3873 | ThreadPoolDataset::ThreadPoolDataset(const ::tensorflow::Scope& scope, |
3874 | ::tensorflow::Input input_dataset, |
3875 | ::tensorflow::Input thread_pool, const |
3876 | DataTypeSlice& output_types, const |
3877 | gtl::ArraySlice<PartialTensorShape>& |
3878 | output_shapes) { |
3879 | if (!scope.ok()) return; |
3880 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3881 | if (!scope.ok()) return; |
3882 | auto _thread_pool = ::tensorflow::ops::AsNodeOut(scope, thread_pool); |
3883 | if (!scope.ok()) return; |
3884 | ::tensorflow::Node* ret; |
3885 | const auto unique_name = scope.GetUniqueNameForOp("ThreadPoolDataset" ); |
3886 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ThreadPoolDataset" ) |
3887 | .Input(_input_dataset) |
3888 | .Input(_thread_pool) |
3889 | .Attr("output_types" , output_types) |
3890 | .Attr("output_shapes" , output_shapes) |
3891 | ; |
3892 | scope.UpdateBuilder(&builder); |
3893 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3894 | if (!scope.ok()) return; |
3895 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3896 | this->operation = Operation(ret); |
3897 | this->handle = Output(ret, 0); |
3898 | } |
3899 | |
3900 | ThreadPoolHandle::ThreadPoolHandle(const ::tensorflow::Scope& scope, int64 |
3901 | num_threads, StringPiece display_name, const |
3902 | ThreadPoolHandle::Attrs& attrs) { |
3903 | if (!scope.ok()) return; |
3904 | ::tensorflow::Node* ret; |
3905 | const auto unique_name = scope.GetUniqueNameForOp("ThreadPoolHandle" ); |
3906 | auto builder = ::tensorflow::NodeBuilder(unique_name, "ThreadPoolHandle" ) |
3907 | .Attr("num_threads" , num_threads) |
3908 | .Attr("max_intra_op_parallelism" , attrs.max_intra_op_parallelism_) |
3909 | .Attr("display_name" , display_name) |
3910 | .Attr("container" , attrs.container_) |
3911 | .Attr("shared_name" , attrs.shared_name_) |
3912 | ; |
3913 | scope.UpdateBuilder(&builder); |
3914 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3915 | if (!scope.ok()) return; |
3916 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3917 | this->operation = Operation(ret); |
3918 | this->handle = Output(ret, 0); |
3919 | } |
3920 | |
3921 | ThreadPoolHandle::ThreadPoolHandle(const ::tensorflow::Scope& scope, int64 |
3922 | num_threads, StringPiece display_name) |
3923 | : ThreadPoolHandle(scope, num_threads, display_name, ThreadPoolHandle::Attrs()) {} |
3924 | |
3925 | UnbatchDataset::UnbatchDataset(const ::tensorflow::Scope& scope, |
3926 | ::tensorflow::Input input_dataset, const |
3927 | DataTypeSlice& output_types, const |
3928 | gtl::ArraySlice<PartialTensorShape>& |
3929 | output_shapes, const UnbatchDataset::Attrs& |
3930 | attrs) { |
3931 | if (!scope.ok()) return; |
3932 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3933 | if (!scope.ok()) return; |
3934 | ::tensorflow::Node* ret; |
3935 | const auto unique_name = scope.GetUniqueNameForOp("UnbatchDataset" ); |
3936 | auto builder = ::tensorflow::NodeBuilder(unique_name, "UnbatchDataset" ) |
3937 | .Input(_input_dataset) |
3938 | .Attr("output_types" , output_types) |
3939 | .Attr("output_shapes" , output_shapes) |
3940 | .Attr("metadata" , attrs.metadata_) |
3941 | ; |
3942 | scope.UpdateBuilder(&builder); |
3943 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3944 | if (!scope.ok()) return; |
3945 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3946 | this->operation = Operation(ret); |
3947 | this->handle = Output(ret, 0); |
3948 | } |
3949 | |
3950 | UnbatchDataset::UnbatchDataset(const ::tensorflow::Scope& scope, |
3951 | ::tensorflow::Input input_dataset, const |
3952 | DataTypeSlice& output_types, const |
3953 | gtl::ArraySlice<PartialTensorShape>& |
3954 | output_shapes) |
3955 | : UnbatchDataset(scope, input_dataset, output_types, output_shapes, UnbatchDataset::Attrs()) {} |
3956 | |
3957 | UncompressElement::UncompressElement(const ::tensorflow::Scope& scope, |
3958 | ::tensorflow::Input compressed, const |
3959 | DataTypeSlice& output_types, const |
3960 | gtl::ArraySlice<PartialTensorShape>& |
3961 | output_shapes) { |
3962 | if (!scope.ok()) return; |
3963 | auto _compressed = ::tensorflow::ops::AsNodeOut(scope, compressed); |
3964 | if (!scope.ok()) return; |
3965 | ::tensorflow::Node* ret; |
3966 | const auto unique_name = scope.GetUniqueNameForOp("UncompressElement" ); |
3967 | auto builder = ::tensorflow::NodeBuilder(unique_name, "UncompressElement" ) |
3968 | .Input(_compressed) |
3969 | .Attr("output_types" , output_types) |
3970 | .Attr("output_shapes" , output_shapes) |
3971 | ; |
3972 | scope.UpdateBuilder(&builder); |
3973 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3974 | if (!scope.ok()) return; |
3975 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
3976 | this->operation = Operation(ret); |
3977 | for (int32 i = 0; i < ret->num_outputs(); ++i) |
3978 | this->components.push_back(Output(ret, i)); |
3979 | } |
3980 | |
3981 | UniqueDataset::UniqueDataset(const ::tensorflow::Scope& scope, |
3982 | ::tensorflow::Input input_dataset, const |
3983 | DataTypeSlice& output_types, const |
3984 | gtl::ArraySlice<PartialTensorShape>& |
3985 | output_shapes, const UniqueDataset::Attrs& attrs) { |
3986 | if (!scope.ok()) return; |
3987 | auto _input_dataset = ::tensorflow::ops::AsNodeOut(scope, input_dataset); |
3988 | if (!scope.ok()) return; |
3989 | ::tensorflow::Node* ret; |
3990 | const auto unique_name = scope.GetUniqueNameForOp("UniqueDataset" ); |
3991 | auto builder = ::tensorflow::NodeBuilder(unique_name, "UniqueDataset" ) |
3992 | .Input(_input_dataset) |
3993 | .Attr("output_types" , output_types) |
3994 | .Attr("output_shapes" , output_shapes) |
3995 | .Attr("metadata" , attrs.metadata_) |
3996 | ; |
3997 | scope.UpdateBuilder(&builder); |
3998 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
3999 | if (!scope.ok()) return; |
4000 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
4001 | this->operation = Operation(ret); |
4002 | this->handle = Output(ret, 0); |
4003 | } |
4004 | |
4005 | UniqueDataset::UniqueDataset(const ::tensorflow::Scope& scope, |
4006 | ::tensorflow::Input input_dataset, const |
4007 | DataTypeSlice& output_types, const |
4008 | gtl::ArraySlice<PartialTensorShape>& |
4009 | output_shapes) |
4010 | : UniqueDataset(scope, input_dataset, output_types, output_shapes, UniqueDataset::Attrs()) {} |
4011 | |
4012 | } // namespace internal |
4013 | } // namespace ops |
4014 | } // namespace tensorflow |
4015 | |