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
7namespace tensorflow {
8namespace ops {
9namespace internal {
10// NOTE: This namespace has internal TensorFlow details that
11// are not part of TensorFlow's public API.
12
13AssertCardinalityDataset::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
43AssertNextDataset::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
70AssertPrevDataset::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
97AutoShardDataset::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
131AutoShardDataset::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
140BytesProducedStatsDataset::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
169CSVDataset::CSVDataset(const ::tensorflow::Scope& scope, ::tensorflow::Input
170 filenames, ::tensorflow::Input compression_type,
171 ::tensorflow::Input buffer_size, ::tensorflow::Input
172 header, ::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 _header = ::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
218CSVDatasetV2::CSVDatasetV2(const ::tensorflow::Scope& scope,
219 ::tensorflow::Input filenames, ::tensorflow::Input
220 compression_type, ::tensorflow::Input buffer_size,
221 ::tensorflow::Input header, ::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 _header = ::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
272ChooseFastestBranchDataset::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
323ChooseFastestDataset::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
349CompressElement::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
367ComputeBatchSize::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
385DataServiceDataset::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
438DataServiceDataset::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
452DataServiceDatasetV2::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
514DataServiceDatasetV2::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
531DataServiceDatasetV3::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
596DataServiceDatasetV3::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
614DataServiceDatasetV4::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
679DataServiceDatasetV4::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
697DatasetFromGraph::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
715DatasetToTFRecord::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
741DenseToSparseBatchDataset::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
776DirectedInterleaveDataset::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
809DirectedInterleaveDataset::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
820DummyIterationCounter::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
834ExperimentalAssertNextDataset::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
868ExperimentalAutoShardDataset::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
908ExperimentalAutoShardDataset::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
923ExperimentalBytesProducedStatsDataset::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
957ExperimentalCSVDataset::ExperimentalCSVDataset(const ::tensorflow::Scope&
958 scope, ::tensorflow::Input
959 filenames, ::tensorflow::Input
960 compression_type,
961 ::tensorflow::Input buffer_size,
962 ::tensorflow::Input header,
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 _header = ::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
1013ExperimentalChooseFastestDataset::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
1045ExperimentalDatasetCardinality::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
1066ExperimentalDatasetToTFRecord::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
1097ExperimentalDenseToSparseBatchDataset::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
1136ExperimentalDirectedInterleaveDataset::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
1170ExperimentalGroupByReducerDataset::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
1235ExperimentalGroupByWindowDataset::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
1291ExperimentalIgnoreErrorsDataset::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
1324ExperimentalIgnoreErrorsDataset::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
1337ExperimentalIteratorGetDevice::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
1358ExperimentalLMDBDataset::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
1383ExperimentalLatencyStatsDataset::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
1416ExperimentalMapAndBatchDataset::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
1472ExperimentalMapAndBatchDataset::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
1495ExperimentalMapDataset::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
1531ExperimentalMapDataset::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
1543ExperimentalMatchingFilesDataset::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
1564ExperimentalMaxIntraOpParallelismDataset::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
1587ExperimentalNonSerializableDataset::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
1616ExperimentalParallelInterleaveDataset::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
1679ExperimentalParseExampleDataset::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
1738ExperimentalParseExampleDataset::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
1767ExperimentalPrivateThreadPoolDataset::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
1801ExperimentalRandomDataset::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
1830ExperimentalRebatchDataset::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
1865ExperimentalRebatchDataset::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
1878ExperimentalScanDataset::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
1918ExperimentalScanDataset::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
1932ExperimentalSetStatsAggregatorDataset::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
1976ExperimentalSleepDataset::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
2006ExperimentalSlidingWindowDataset::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
2050ExperimentalSqlDataset::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
2083ExperimentalStatsAggregatorHandle::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
2104ExperimentalStatsAggregatorHandle::ExperimentalStatsAggregatorHandle(const
2105 ::tensorflow::Scope&
2106 scope)
2107 : ExperimentalStatsAggregatorHandle(scope, ExperimentalStatsAggregatorHandle::Attrs()) {}
2108
2109ExperimentalStatsAggregatorSummary::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
2130ExperimentalTakeWhileDataset::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
2165ExperimentalThreadPoolDataset::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
2198ExperimentalThreadPoolHandle::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
2224ExperimentalThreadPoolHandle::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
2232ExperimentalUnbatchDataset::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
2259ExperimentalUniqueDataset::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
2284GetElementAtIndex::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
2312GroupByReducerDataset::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
2364GroupByWindowDataset::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
2411GroupByWindowDataset::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
2428IgnoreErrorsDataset::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
2454IgnoreErrorsDataset::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
2462InitializeTableFromDataset::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
2488IteratorGetDevice::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
2506LMDBDataset::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
2527LatencyStatsDataset::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
2554LegacyParallelInterleaveDatasetV2::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
2616LegacyParallelInterleaveDatasetV2::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
2641ListDataset::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
2665ListDataset::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
2671LoadDataset::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
2700LoadDataset::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
2707MapAndBatchDataset::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
2751MapAndBatchDataset::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
2763MatchingFilesDataset::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
2781MaxIntraOpParallelismDataset::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
2813NonSerializableDataset::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
2838ParallelInterleaveDataset::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
2898ParallelInterleaveDataset::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
2920ParseExampleDataset::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
2969ParseExampleDataset::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
2987ParseExampleDatasetV2::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
3037ParseExampleDatasetV2::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
3055PrivateThreadPoolDataset::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
3085RandomDataset::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
3112RandomDataset::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
3119RebatchDataset::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
3148RebatchDataset::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
3156RebatchDatasetV2::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
3187RegisterDataset::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
3218RegisterDataset::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
3225RegisterDatasetV2::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
3257RegisterDatasetV2::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
3264SamplingDataset::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
3298SaveDataset::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
3328SaveDataset::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
3334SaveDatasetV2::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
3368SaveDatasetV2::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
3377ScanDataset::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
3411ScanDataset::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
3419SetStatsAggregatorDataset::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
3458SleepDataset::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
3484SlidingWindowDataset::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
3522SlidingWindowDataset::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
3533SnapshotDataset::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
3575SnapshotDataset::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
3583SnapshotDatasetReader::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
3616SnapshotDatasetReader::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
3625SnapshotDatasetV2::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
3673SnapshotDatasetV2::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
3687SnapshotNestedDatasetReader::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
3714SqlDataset::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
3743StatsAggregatorHandle::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
3762StatsAggregatorHandle::StatsAggregatorHandle(const ::tensorflow::Scope& scope)
3763 : StatsAggregatorHandle(scope, StatsAggregatorHandle::Attrs()) {}
3764
3765StatsAggregatorHandleV2::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
3784StatsAggregatorHandleV2::StatsAggregatorHandleV2(const ::tensorflow::Scope&
3785 scope)
3786 : StatsAggregatorHandleV2(scope, StatsAggregatorHandleV2::Attrs()) {}
3787
3788StatsAggregatorSetSummaryWriter::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
3814StatsAggregatorSummary::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
3833TakeWhileDataset::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
3864TakeWhileDataset::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
3873ThreadPoolDataset::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
3900ThreadPoolHandle::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
3921ThreadPoolHandle::ThreadPoolHandle(const ::tensorflow::Scope& scope, int64
3922 num_threads, StringPiece display_name)
3923 : ThreadPoolHandle(scope, num_threads, display_name, ThreadPoolHandle::Attrs()) {}
3924
3925UnbatchDataset::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
3950UnbatchDataset::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
3957UncompressElement::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
3981UniqueDataset::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
4005UniqueDataset::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