B ٻd @s\dZddlZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl m Z ddl mZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#dd lmZ$ddlm%Z%ddlm&Z'ddlm(Z(ddlm)Z)ddlm*Z*ddlm+Z+ddl,m-Z-ddl,m.Z.ddl,m/Z/ddl,m0Z0dd l,m1Z2dd!l,m3Z3dd"l,m4Z4dd#l,m5Z5dd$l,m6Z6dd%l,m7Z7dd&l,m8Z8dd'l,m9Z9dd(l:m;Z;dd)lZ?dd+lZYd?ZZeKd@TeUdAeKdBTeUdCdDdEZ[dFdGZ\eKdHgdIGdJdKdKeIj]e?j^ej_ej`dLZaeKdHgdIGdMdNdNeaZbecr|eaZdnebZdGdOdPdPebZedQdRZfeKdSgdIdTdUZgeKdVgdIddWdXZheKdYdZd[ZieKd\gdId]d^ZjeKd_gdId`daZkeKdbgdIdcddZlGdedfdfeaZmGdgdhdheaZnGdidjdjenZoGdkdldleaZpGdmdndnej_ZqeKdodpdqZreKdrdsdtZseKdududvgdIGdwdxdxe+jtZuGdydzdzZvGd{d|d|eAjwZxGd}d~d~emZyGdddemZzGdddemZ{GdddeaZ|GdddeaZ}GdddeoZ~GdddemZGdddeoZGdddeoZGdddeoZGdddeoZGdddeoZGdddenZGdddenZddZddZddZddZGdddenZGdddenZGdddenZGdddenZGdddenZGdddenZGdddeoZGdddenZGdddeoZddZGdddenZGdddenZGdddenZGdddemZddZdddZdddĄZddƄZddȄZddʄZGdd̄deoZGdd΄deoZGddЄdeoZGdd҄denZGddԄdeaZddքZdd؄ZejddڄZdaeKd܃ddބZddZdS)zPython wrappers for Datasets.N)dataset_metadata_pb2)dataset_options_pb2) graph_pb2)tf2) iterator_ops)options)structured_function)nest) random_seed) structure)traverse)context)auto_control_deps)auto_control_deps_utils)composite_tensor) constant_op)dtypes)function)ops) smart_cond) sparse_tensor) tensor_shape) tensor_spec) tensor_util) type_spec) array_ops) check_ops)control_flow_ops)gen_dataset_ops)gen_experimental_dataset_ops) gen_io_ops)gen_stateless_random_ops) logging_ops)math_ops) random_ops) script_ops) string_ops) ragged_tensor)asset)base)resource)trace) deprecation) lazy_loader)collections_abc) tf_export wrap_functionz%tensorflow.python.eager.wrap_function def_functionz$tensorflow.python.eager.def_function parsing_opsz!tensorflow.python.ops.parsing_ops ReduceDatasetz data.AUTOTUNEAUTOTUNEzdata.experimental.AUTOTUNEZGZIPNONEzdataset_spec.pbzdata.INFINITE_CARDINALITYINFINITEzdata.UNKNOWN_CARDINALITYUNKNOWNcCs|std|dS)Na Invalid `name`. The argument `name` needs to be a valid identifier. Value is considered a valid identifier if it only contains alphanumeric characters (a-z), (A-Z), and (0-9), or underscores (_). A valid identifier cannot start with a number, or contain any spaces.zutf-8) isidentifier ValueErrorencode)namer>X/var/www/html/venv/lib/python3.7/site-packages/tensorflow/python/data/ops/dataset_ops.py_validate_and_encodetsr@cCs t|tjr|St|SdS)z0Returns the type of `value` if it is a TypeSpec.N) isinstancerTypeSpec value_typetype)valuer>r>r? _get_type~s rFz data.Dataset)Zv1csVeZdZdZddZeddZejddZe ddd dde j j fd d Z d d Zejjffdd ZddZejddZeddZejddZddZddZeddZddZdd Zd!d"Zd#d$ZeZ d%d&Z!ej"d'd(Z#d)d*Z$d+d,Z%d-d.Z&ed/d0Z'ed1d2Z(ed3d4Z)ed5d6Z*ed7d8Z+ed9d:Z,e-dd;d<Z.e-dd=d>Z/Gd?d@d@Z0e-e ddAdBdCddDdEZ1e-dFdGZ2e-ddHdIZ3ddJdKZ4e-dLdMe5j6dfdNdOZ7ddQdRZ8ddSdTZ9e-ddUdVZ:ddWdXZ;ddYdZZdd`daZ?ddbdcZ@ddddeZAddfdgZBe-ddhdiZCddjdkZDddldmZEddndoZFddpdqZGddrdsZHddtduZIddvdwZJdxdyZKddzd{ZLdd|d}ZMdd~dZNdddZOdddZPddZQdddZRdddZSe-dddZTdddZUdddZVdddZWdddZXdddZYe-dddZZe-dddZ[Z\S) DatasetV2ax Represents a potentially large set of elements. The `tf.data.Dataset` API supports writing descriptive and efficient input pipelines. `Dataset` usage follows a common pattern: 1. Create a source dataset from your input data. 2. Apply dataset transformations to preprocess the data. 3. Iterate over the dataset and process the elements. Iteration happens in a streaming fashion, so the full dataset does not need to fit into memory. Source Datasets: The simplest way to create a dataset is to create it from a python `list`: >>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3]) >>> for element in dataset: ... print(element) tf.Tensor(1, shape=(), dtype=int32) tf.Tensor(2, shape=(), dtype=int32) tf.Tensor(3, shape=(), dtype=int32) To process lines from files, use `tf.data.TextLineDataset`: >>> dataset = tf.data.TextLineDataset(["file1.txt", "file2.txt"]) To process records written in the `TFRecord` format, use `TFRecordDataset`: >>> dataset = tf.data.TFRecordDataset(["file1.tfrecords", "file2.tfrecords"]) To create a dataset of all files matching a pattern, use `tf.data.Dataset.list_files`: ```python dataset = tf.data.Dataset.list_files("/path/*.txt") ``` See `tf.data.FixedLengthRecordDataset` and `tf.data.Dataset.from_generator` for more ways to create datasets. Transformations: Once you have a dataset, you can apply transformations to prepare the data for your model: >>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3]) >>> dataset = dataset.map(lambda x: x*2) >>> list(dataset.as_numpy_iterator()) [2, 4, 6] Common Terms: **Element**: A single output from calling `next()` on a dataset iterator. Elements may be nested structures containing multiple components. For example, the element `(1, (3, "apple"))` has one tuple nested in another tuple. The components are `1`, `3`, and `"apple"`. **Component**: The leaf in the nested structure of an element. Supported types: Elements can be nested structures of tuples, named tuples, and dictionaries. Note that Python lists are *not* treated as nested structures of components. Instead, lists are converted to tensors and treated as components. For example, the element `(1, [1, 2, 3])` has only two components; the tensor `1` and the tensor `[1, 2, 3]`. Element components can be of any type representable by `tf.TypeSpec`, including `tf.Tensor`, `tf.data.Dataset`, `tf.sparse.SparseTensor`, `tf.RaggedTensor`, and `tf.TensorArray`. ```python a = 1 # Integer element b = 2.0 # Float element c = (1, 2) # Tuple element with 2 components d = {"a": (2, 2), "b": 3} # Dict element with 3 components Point = collections.namedtuple("Point", ["x", "y"]) e = Point(1, 2) # Named tuple f = tf.data.Dataset.range(10) # Dataset element ``` For more information, read [this guide](https://www.tensorflow.org/guide/data). cCs||_t|_t|_x|D]}d}t|t rvt |drt|j t slt dt|dt|j d|j j}n0t|t r|j}nt dt|dt|d|dk r$|j||_q$W|jddS)aWCreates a DatasetV2 object. This is a difference between DatasetV1 and DatasetV2. DatasetV1 does not take anything in its constructor whereas in the DatasetV2, we expect subclasses to create a variant_tensor and pass it in to the super() call. Args: variant_tensor: A DT_VARIANT tensor that represents the dataset. N_datasetzEach input of dataset z; should be a subclass of `tf.data.Dataset` but encountered .F)_variant_tensor_attrrget_default_graph _graph_attr options_libOptions _options_attr_inputsrA DatasetV1hasattrrHrG TypeErrorrDmerge _set_mutable)selfvariant_tensor input_datasetZ input_optionsr>r>r?__init__s$        zDatasetV2.__init__cCs|jS)N)rJ)rVr>r>r?_variant_tensorszDatasetV2._variant_tensorcCs tddS)Nz2The `_variant_tensor` property cannot be modified.)r;)rV_r>r>r?rZ sNz!Use external_state_policy insteadallow_statefulcCsB|r|j}tj|j||dS|r2tj|j||dStj|j|dS)aProduces serialized graph representation of the dataset. Args: allow_stateful: If true, we allow stateful ops to be present in the graph def. In that case, the state in these ops would be thrown away. strip_device_assignment: If true, non-local (i.e. job and task) device assignment is stripped from ops in the serialized graph. external_state_policy: The ExternalStatePolicy enum that determines how we handle input pipelines that depend on external state. By default, its set to WARN. Returns: A scalar `tf.Tensor` of `tf.string` type, representing this dataset as a serialized graph. )external_state_policystrip_device_assignment)r\r^)r\)rErZdataset_to_graph_v2rZZdataset_to_graph)rVr\r^r]policyr>r>r?_as_serialized_graphszDatasetV2._as_serialized_graphc si}x(|jD]jdr d|jd<q W|s6iSx|jD]xj|kr>jdj}t2t dt | t j}WdQRXWdQRXfddt|D|j<q>W|S)aFinds and tracks nodes in `graph_def` that refer to asset files. Args: graph_def: Serialized graph representation of this dataset. Returns: A dictionary mapping the node name of an asset constant to a tracked `asset.Asset` object. Z FileIdentityNrrECPUcs4g|],\}}jt|jdt|ddqS)r[T)r= overwrite)Z_track_trackabler(ZAssetr=str).0in)noderVr>r? Lsz1DatasetV2._maybe_track_assets..)rgr= startswithinputattrZtensorr eager_moderdevicer2Z parse_tensorSerializeToStringrstringnumpy enumerate)rV graph_def asset_trackerZ tensor_protoZ node_valuer>)rgrVr?_maybe_track_assets3s      & zDatasetV2._maybe_track_assetsc sZ|tjjkriStjgddfdd}|ttj|f|}t j ||d<|S)NF)Zinput_signatureZ autographcs}|S)N)_trace_variant_creation)r*)rVr>r?_creatorZs z/DatasetV2._trackable_children.._creatorZ_variant_tracker) tracking_baseSaveType SAVEDMODELr1rZget_concrete_functionsuperrG_trackable_children_VariantTrackerrZ)rV save_typekwargsrvchildren) __class__)rVr?r{Rs  zDatasetV2._trackable_childrenc Cs:|j}t|tjstdt:td$t |j t j jd}WdQRXWdQRXg}x|jD]}|jdkrn|j}qnWt|dkrtdt|d|d |d }i}tjr||}x0|D](}d d ||D} tj| d d ||<qWtj|g|d|d} x |D]} | j| jqW| S)a%Traces a function which outputs a variant `tf.Tensor` for this dataset. Note that creating this function involves evaluating an op, and is currently only supported when executing eagerly. Returns: A zero-argument `ConcreteFunction` which outputs a variant `tf.Tensor`. zConstructing a tf.function that reproduces a given dataset is only supported for datasets created eagerly. Please file a feature request if this is important to you.ra)r]NZ_RetvalzBDataset graph is expected to only have one return value but found z return values: rIrcSsg|]}tj|jddqS)r)axis)r expand_dimsZ asset_path)rdr(r>r>r?rhsz5DatasetV2._trace_variant_creation..)rz:0)inputsoutputsZcaptures) rZrArZ EagerTensorNotImplementedErrorr rlrmrZGraphDef FromStringr`rMExternalStatePolicyFAILrprgoprjlenAssertionErrorrKZbuilding_functionrtrconcatr0Zfunction_from_graph_def _functionsr add_to_graphgraph) rVvariantrrZoutput_node_namesrgZoutput_node_nameZfile_path_nodesrskeyZ assets_listZvariant_functionZ used_functionr>r>r?rues<  *        z!DatasetV2._trace_variant_creationcCstt|ddS)z4Returns a list of the input datasets of the dataset.z ._inputs()N)rrD)rVr>r>r?rPszDatasetV2._inputscCs|jS)N)rL)rVr>r>r?_graphszDatasetV2._graphcCs tddS)Nz)The `_graph` property cannot be modified.)r;)rVr[r>r>r?rscCsgS)zReturns a list of functions associated with this dataset. Returns: A list of `StructuredFunctionWrapper` objects. r>)rVr>r>r?rszDatasetV2._functionscCs t|jS)z,Returns the options tensor for this dataset.)rZ get_optionsrZ)rVr>r>r?_optionsszDatasetV2._optionscCs6t}t|dk r2tjt|}|||S)z2Converts options tensor to tf.data.Options object.N)rMrNrconstant_valuerrZ _from_proto)clsZserialized_optionsrZpbr>r>r?_options_tensor_to_optionss   z$DatasetV2._options_tensor_to_optionscCs4tr$||}|d|Std|jS)zReturns the options for this dataset and its inputs. Returns: A `tf.data.Options` object representing the dataset options. FaTo make it possible to preserve tf.data options across serialization boundaries, their implementation has moved to be part of the TensorFlow graph. As a consequence, the options value is in general no longer known at graph construction time. Invoking this method in graph mode retains the legacy behavior of the original implementation, but note that the returned value might not reflect the actual value of the options.)r executing_eagerlyrrrUwarningswarnrO)rVrr>r>r?rs   zDatasetV2.optionscCs@tr8t}d|j_d|j_d|j_d|j_t ||}n|}|S)NF) DEBUG_MODErMrNZautotuneenabledZexperimental_optimizationZfilter_parallelizationZmap_and_batch_fusionZmap_parallelization_OptionsDataset)rVrdatasetr>r>r?_apply_debug_optionss zDatasetV2._apply_debug_optionsc Cs<tstr0t|j t|SQRXntddS)aCreates an iterator for elements of this dataset. The returned iterator implements the Python Iterator protocol. Returns: An `tf.data.Iterator` for the elements of this dataset. Raises: RuntimeError: If not inside of tf.function and not executing eagerly. Nz[`tf.data.Dataset` only supports Python-style iteration in eager mode or within tf.function.) r rrinside_function colocate_withrZr OwnedIterator RuntimeError)rVr>r>r?__iter__s zDatasetV2.__iter__cCsdS)NTr>)rVr>r>r?__bool__szDatasetV2.__bool__cCsDtstd|}|tkr,td|tkr@td|S)a Returns the length of the dataset if it is known and finite. This method requires that you are running in eager mode, and that the length of the dataset is known and non-infinite. When the length may be unknown or infinite, or if you are running in graph mode, use `tf.data.Dataset.cardinality` instead. Returns: An integer representing the length of the dataset. Raises: RuntimeError: If the dataset length is unknown or infinite, or if eager execution is not enabled. za`tf.data.Dataset` only supports `len` in eager mode. Use `tf.data.Dataset.cardinality()` instead.zThe dataset is infinite.zThe dataset length is unknown.)r rrS cardinalityrpr8r9)rVlengthr>r>r?__len__s  zDatasetV2.__len__cCstt|ddS)aThe type specification of an element of this dataset. >>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3]) >>> dataset.element_spec TensorSpec(shape=(), dtype=tf.int32, name=None) For more information, read [this guide](https://www.tensorflow.org/guide/data#dataset_structure). Returns: A (nested) structure of `tf.TypeSpec` objects matching the structure of an element of this dataset and specifying the type of individual components. z.element_spec()N)rrD)rVr>r>r? element_specszDatasetV2.element_speccCs.tt|tr|jn|}d|jd|jdS)N)rDrADatasetV1AdapterrH__name__r)rVtype_r>r>r?__repr__'szDatasetV2.__repr__cs`g}|dfg}xF|rT|\}|dt||fdd|DqWd|S)zReturns a string showing the type of the dataset and its inputs. This string is intended only for debugging purposes, and may change without warning. rz--csg|]}|dfqS)rr>)rdds)depthr>r?rh6sz.DatasetV2.__debug_string__.. )popappendreprextendrPjoin)rVlinesZ to_processrr>)rr?__debug_string__+s   zDatasetV2.__debug_string__cCsXtstdx>t|jD].}t|tjt j t j t jfstd|jqWt|S)aReturns an iterator which converts all elements of the dataset to numpy. Use `as_numpy_iterator` to inspect the content of your dataset. To see element shapes and types, print dataset elements directly instead of using `as_numpy_iterator`. >>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3]) >>> for element in dataset: ... print(element) tf.Tensor(1, shape=(), dtype=int32) tf.Tensor(2, shape=(), dtype=int32) tf.Tensor(3, shape=(), dtype=int32) This method requires that you are running in eager mode and the dataset's element_spec contains only `TensorSpec` components. >>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3]) >>> for element in dataset.as_numpy_iterator(): ... print(element) 1 2 3 >>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3]) >>> print(list(dataset.as_numpy_iterator())) [1, 2, 3] `as_numpy_iterator()` will preserve the nested structure of dataset elements. >>> dataset = tf.data.Dataset.from_tensor_slices({'a': ([1, 2], [3, 4]), ... 'b': [5, 6]}) >>> list(dataset.as_numpy_iterator()) == [{'a': (1, 3), 'b': 5}, ... {'a': (2, 4), 'b': 6}] True Returns: An iterable over the elements of the dataset, with their tensors converted to numpy arrays. Raises: TypeError: if an element contains a non-`Tensor` value. RuntimeError: if eager execution is not enabled. zF`tf.data.Dataset.as_numpy_iterator()` is only supported in eager mode.z``tf.data.Dataset.as_numpy_iterator()` is not supported for datasets that produce values of type )r rrr flattenrrAr TensorSpecr'ZRaggedTensorSpecsparse_tensor_libZSparseTensorSpecr ZNoneTensorSpecrSrC_NumpyIterator)rVcomponent_specr>r>r?as_numpy_iterator9s-zDatasetV2.as_numpy_iteratorcCs t|jS)zReturns a list `tf.TensorShapes`s for the element tensor representation. Returns: A list `tf.TensorShapes`s for the element tensor representation. )r get_flat_tensor_shapesr)rVr>r>r? _flat_shapestszDatasetV2._flat_shapescCs t|jS)zReturns a list `tf.DType`s for the element tensor representation. Returns: A list `tf.DType`s for the element tensor representation. )r get_flat_tensor_typesr)rVr>r>r? _flat_types}szDatasetV2._flat_typescCs|j|jdS)a Helper for setting `output_shapes` and `output_types` attrs of an op. Most dataset op constructors expect `output_shapes` and `output_types` arguments that represent the flattened structure of an element. This helper function generates these attrs as a keyword argument dictionary, allowing `Dataset._variant_tensor` implementations to pass `**self._flat_structure` to the op constructor. Returns: A dictionary of keyword arguments that can be passed to a dataset op constructor. ) output_shapes output_types)rr)rVr>r>r?_flat_structureszDatasetV2._flat_structurecCst}|jrt|j|_|S)z'Helper for generating dataset metadata.)rMetadata_namer@r=)rVmetadatar>r>r? _metadatas zDatasetV2._metadatacCs|j|j|jdS)apHelper for generating arguments that are common across most dataset ops. Most dataset op constructors expect `output_shapes` and `output_types` arguments that represent the flattened structure of an element, as well as a `metadata` argument for additional metadata such as user-defined dataset name. This helper function generates common attributes as a keyword argument dictionary, allowing `Dataset._variant_tensor` implementations to pass `**self._common_args` to the op constructor. Returns: A dictionary of keyword arguments that can be passed to a dataset op constructor. )rrr)rrnrr)rVr>r>r? _common_argsszDatasetV2._common_argscCs t|jS)N) DatasetSpecr)rVr>r>r? _type_specszDatasetV2._type_speccCs t||dS)aCreates a `Dataset` with a single element, comprising the given tensors. `from_tensors` produces a dataset containing only a single element. To slice the input tensor into multiple elements, use `from_tensor_slices` instead. >>> dataset = tf.data.Dataset.from_tensors([1, 2, 3]) >>> list(dataset.as_numpy_iterator()) [array([1, 2, 3], dtype=int32)] >>> dataset = tf.data.Dataset.from_tensors(([1, 2, 3], 'A')) >>> list(dataset.as_numpy_iterator()) [(array([1, 2, 3], dtype=int32), b'A')] >>> # You can use `from_tensors` to produce a dataset which repeats >>> # the same example many times. >>> example = tf.constant([1,2,3]) >>> dataset = tf.data.Dataset.from_tensors(example).repeat(2) >>> list(dataset.as_numpy_iterator()) [array([1, 2, 3], dtype=int32), array([1, 2, 3], dtype=int32)] Note that if `tensors` contains a NumPy array, and eager execution is not enabled, the values will be embedded in the graph as one or more `tf.constant` operations. For large datasets (> 1 GB), this can waste memory and run into byte limits of graph serialization. If `tensors` contains one or more large NumPy arrays, consider the alternative described in [this guide](https://tensorflow.org/guide/data#consuming_numpy_arrays). Args: tensors: A dataset "element". Supported values are documented [here](https://www.tensorflow.org/guide/data#dataset_structure). name: (Optional.) A name for the tf.data operation. Returns: Dataset: A `Dataset`. )r=) TensorDataset)tensorsr=r>r>r? from_tensorss%zDatasetV2.from_tensorscCsddlm}|||S)a Creates a `Dataset` whose elements are slices of the given tensors. The given tensors are sliced along their first dimension. This operation preserves the structure of the input tensors, removing the first dimension of each tensor and using it as the dataset dimension. All input tensors must have the same size in their first dimensions. >>> # Slicing a 1D tensor produces scalar tensor elements. >>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3]) >>> list(dataset.as_numpy_iterator()) [1, 2, 3] >>> # Slicing a 2D tensor produces 1D tensor elements. >>> dataset = tf.data.Dataset.from_tensor_slices([[1, 2], [3, 4]]) >>> list(dataset.as_numpy_iterator()) [array([1, 2], dtype=int32), array([3, 4], dtype=int32)] >>> # Slicing a tuple of 1D tensors produces tuple elements containing >>> # scalar tensors. >>> dataset = tf.data.Dataset.from_tensor_slices(([1, 2], [3, 4], [5, 6])) >>> list(dataset.as_numpy_iterator()) [(1, 3, 5), (2, 4, 6)] >>> # Dictionary structure is also preserved. >>> dataset = tf.data.Dataset.from_tensor_slices({"a": [1, 2], "b": [3, 4]}) >>> list(dataset.as_numpy_iterator()) == [{'a': 1, 'b': 3}, ... {'a': 2, 'b': 4}] True >>> # Two tensors can be combined into one Dataset object. >>> features = tf.constant([[1, 3], [2, 1], [3, 3]]) # ==> 3x2 tensor >>> labels = tf.constant(['A', 'B', 'A']) # ==> 3x1 tensor >>> dataset = Dataset.from_tensor_slices((features, labels)) >>> # Both the features and the labels tensors can be converted >>> # to a Dataset object separately and combined after. >>> features_dataset = Dataset.from_tensor_slices(features) >>> labels_dataset = Dataset.from_tensor_slices(labels) >>> dataset = Dataset.zip((features_dataset, labels_dataset)) >>> # A batched feature and label set can be converted to a Dataset >>> # in similar fashion. >>> batched_features = tf.constant([[[1, 3], [2, 3]], ... [[2, 1], [1, 2]], ... [[3, 3], [3, 2]]], shape=(3, 2, 2)) >>> batched_labels = tf.constant([['A', 'A'], ... ['B', 'B'], ... ['A', 'B']], shape=(3, 2, 1)) >>> dataset = Dataset.from_tensor_slices((batched_features, batched_labels)) >>> for element in dataset.as_numpy_iterator(): ... print(element) (array([[1, 3], [2, 3]], dtype=int32), array([[b'A'], [b'A']], dtype=object)) (array([[2, 1], [1, 2]], dtype=int32), array([[b'B'], [b'B']], dtype=object)) (array([[3, 3], [3, 2]], dtype=int32), array([[b'A'], [b'B']], dtype=object)) Note that if `tensors` contains a NumPy array, and eager execution is not enabled, the values will be embedded in the graph as one or more `tf.constant` operations. For large datasets (> 1 GB), this can waste memory and run into byte limits of graph serialization. If `tensors` contains one or more large NumPy arrays, consider the alternative described in [this guide]( https://tensorflow.org/guide/data#consuming_numpy_arrays). Args: tensors: A dataset element, whose components have the same first dimension. Supported values are documented [here](https://www.tensorflow.org/guide/data#dataset_structure). name: (Optional.) A name for the tf.data operation. Returns: Dataset: A `Dataset`. r)from_tensor_slices_op)tensorflow.python.data.opsrfrom_tensor_slices)rr=rr>r>r?rsP zDatasetV2.from_tensor_slicesc@s8eZdZdZddZddZddZdd Zd d Zd S) zDatasetV2._GeneratorStatea Stores outstanding iterators created from a Python generator. This class keeps track of potentially multiple iterators that may have been created from a generator, e.g. in the case that the dataset is repeated, or nested within a parallel computation. cCs&||_t|_d|_i|_i|_dS)Nr) _generator threadingLock_lock_next_id_args _iterators)rV generatorr>r>r?rY<s  z"DatasetV2._GeneratorState.__init__cCst|tjr|S|S)N)rAnpndarrayitem)rV iterator_idr>r>r? _normalize_idCs z'DatasetV2._GeneratorState._normalize_idc Gs@|j|j}|jd7_WdQRX||j|<tj|tjdS)Nr)dtype)rrrrarrayint64)rVargsretr>r>r? get_next_idJs  z%DatasetV2._GeneratorState.get_next_idcCsN||}y |j|Stk rHt|j|j|}||j|<|SXdS)N)rrKeyErroriterrrr)rVriteratorr>r>r? get_iteratorTs   z&DatasetV2._GeneratorState.get_iteratorcCs|j||=dS)N)rr)rVrr>r>r?iterator_completed]sz,DatasetV2._GeneratorState.iterator_completedN) r __module__ __qualname____doc__rYrrrrr>r>r>r?_GeneratorState4s   rzUse output_signature insteadrrc st|stddk rndk r(tddk r8tdxDtD]$}t|tjsDtdt|dqDWndkr~tddkrˆdkrtdd nt t j t t j td d tDrtd d tDtdd tDdkr$dnttjddt|fddfddfddfdd}d}tj|d} | j|dS)aCreates a `Dataset` whose elements are generated by `generator`. Note: The current implementation of `Dataset.from_generator()` uses `tf.numpy_function` and inherits the same constraints. In particular, it requires the dataset and iterator related operations to be placed on a device in the same process as the Python program that called `Dataset.from_generator()`. In particular, using `from_generator` will preclude the use of tf.data service for scaling out dataset processing. The body of `generator` will not be serialized in a `GraphDef`, and you should not use this method if you need to serialize your model and restore it in a different environment. The `generator` argument must be a callable object that returns an object that supports the `iter()` protocol (e.g. a generator function). The elements generated by `generator` must be compatible with either the given `output_signature` argument or with the given `output_types` and (optionally) `output_shapes` arguments, whichever was specified. The recommended way to call `from_generator` is to use the `output_signature` argument. In this case the output will be assumed to consist of objects with the classes, shapes and types defined by `tf.TypeSpec` objects from `output_signature` argument: >>> def gen(): ... ragged_tensor = tf.ragged.constant([[1, 2], [3]]) ... yield 42, ragged_tensor >>> >>> dataset = tf.data.Dataset.from_generator( ... gen, ... output_signature=( ... tf.TensorSpec(shape=(), dtype=tf.int32), ... tf.RaggedTensorSpec(shape=(2, None), dtype=tf.int32))) >>> >>> list(dataset.take(1)) [(, )] There is also a deprecated way to call `from_generator` by either with `output_types` argument alone or together with `output_shapes` argument. In this case the output of the function will be assumed to consist of `tf.Tensor` objects with the types defined by `output_types` and with the shapes which are either unknown or defined by `output_shapes`. Note: If `generator` depends on mutable global variables or other external state, be aware that the runtime may invoke `generator` multiple times (in order to support repeating the `Dataset`) and at any time between the call to `Dataset.from_generator()` and the production of the first element from the generator. Mutating global variables or external state can cause undefined behavior, and we recommend that you explicitly cache any external state in `generator` before calling `Dataset.from_generator()`. Note: While the `output_signature` parameter makes it possible to yield `Dataset` elements, the scope of `Dataset.from_generator()` should be limited to logic that cannot be expressed through tf.data operations. Using tf.data operations within the generator function is an anti-pattern and may result in incremental memory growth. Args: generator: A callable object that returns an object that supports the `iter()` protocol. If `args` is not specified, `generator` must take no arguments; otherwise it must take as many arguments as there are values in `args`. output_types: (Optional.) A (nested) structure of `tf.DType` objects corresponding to each component of an element yielded by `generator`. output_shapes: (Optional.) A (nested) structure of `tf.TensorShape` objects corresponding to each component of an element yielded by `generator`. args: (Optional.) A tuple of `tf.Tensor` objects that will be evaluated and passed to `generator` as NumPy-array arguments. output_signature: (Optional.) A (nested) structure of `tf.TypeSpec` objects corresponding to each component of an element yielded by `generator`. name: (Optional.) A name for the tf.data operations used by `from_generator`. Returns: Dataset: A `Dataset`. z&`generator` must be a Python callable.NzZThe `output_types` argument can not be used together with the `output_signature` argument.z[The `output_shapes` argument can not be used together with the `output_signature` argument.zU`output_signature` must contain objects that are subclass of `tf.TypeSpec` but found z which is not.zzTo specify the output signature you need to provide either the `output_signature` argument or the `output_types` argument.cSs tdS)N)r TensorShape)r[r>r>r?z*DatasetV2.from_generator..css|]}t|tjVqdS)N)rArr)rdxr>r>r? sz+DatasetV2.from_generator..cSsg|] }|jqSr>)r)rdrr>r>r?rhsz,DatasetV2.from_generator..cSsg|] }|jqSr>)shape)rdrr>r>r?rhsr>r)r=cstjtjS)aUCreates a unique `iterator_id` for each pass over the dataset. The returned `iterator_id` disambiguates between multiple concurrently existing iterators. Args: unused_dummy: Ignored value. Returns: A `tf.int64` tensor whose value uniquely identifies an iterator in `generator_state`. )r%numpy_functionrrr)Z unused_dummy)rgenerator_stater>r?get_iterator_id_fns z4DatasetV2.from_generator..get_iterator_id_fncsrrddtDtfdd}t||g}t|ttfs\|g}dk rx t|D]\}}||qpWt |St }fdd}tj ||g|dSdS)aGenerates the next element from iterator with ID `iterator_id_t`. We map this function across an infinite repetition of the `iterator_id_t`, and raise `StopIteration` to terminate the iteration. Args: iterator_id_t: A `tf.int64` tensor whose value uniquely identifies the iterator in `generator_state` from which to generate an element. Returns: The next element to generate from the iterator. cSsg|]}t|qSr>)rZas_dtype)rddtr>r>r?rhszGDatasetV2.from_generator..generator_next_fn..c sDt|}yt|}Wn>ttfk r\}ztdd|d|Wdd}~XYnXg}xtt|D]f\}}y|tj j ||j dWqnttfk r}ztd|j d|d|Wdd}~XYqnXqnWxft|D]V\}}} |j |j krtd|j d|j d | |jstd |jd | d qW|S) z7A `py_func` that will be called to invoke the iterator.ze`generator` yielded an element that did not match the expected structure. The expected structure was z, but the yielded element was rIN)rzg`generator` yielded an element that could not be converted to the expected type. The expected type was z'`generator` yielded an element of type z where an element of type z was expected.z(`generator` yielded an element of shape z where an element of shape )nextrr flatten_up_torSr;ziprr%Z FuncRegistry_convertas_numpy_dtyper=ris_compatible_withr) rvaluesZflattened_valueseZ ret_arraysrrZ ret_arrayZexpected_dtypeZexpected_shape)flattened_shapesflattened_typesrrr>r?generator_py_func s8 zNDatasetV2.from_generator..generator_next_fn..generator_py_funcNc st|}yt|}Wn>ttfk r`}ztdd|d|Wdd}~XYnXt|}t|std|ddt |S)z7A `py_func` that will be called to invoke the iterator.ze`generator` yielded an element that did not match the expected structure. The expected structure was z, but the yielded element was rINz"`generator` yielded an element of z where an element of z was expected.) rrrpr normalize_elementrSr;type_spec_from_valueare_compatibleto_tensor_list)rrrZ values_spec)routput_signaturer>r?rMs  )inpZTout) r rr%rrAlisttupler set_shapepack_sequence_asr rZ eager_py_func) iterator_id_trZ flat_valuesZret_trZflat_output_types)rrr r)rrr?generator_next_fns"  /  z3DatasetV2.from_generator..generator_next_fncsfdd}t||gtjS)zBReleases host-side state for the iterator with ID `iterator_id_t`.cs|tjdtjdS)Nr)r)rrrr)r)rr>r?finalize_py_funcks zGDatasetV2.from_generator..finalize_fn..finalize_py_func)r%rrr)rr)rr>r? finalize_fnhs z-DatasetV2.from_generator..finalize_fncst|dS)N)r=)_GeneratorDataset)Z dummy_arg)rrrr=r r>r? flat_map_fnysz-DatasetV2.from_generator..flat_map_fnr)callablerSr rrArrBrD map_structuremap_structure_up_toras_shaperrallrr rZconvert_n_to_tensorrGrDatasetrflat_map) rrrrr r=specrdummyZ id_datasetr>) rrrrrr=rr rr?from_generator`sPY   p zDatasetV2.from_generatorcOs t||S)aCreates a `Dataset` of a step-separated range of values. >>> list(Dataset.range(5).as_numpy_iterator()) [0, 1, 2, 3, 4] >>> list(Dataset.range(2, 5).as_numpy_iterator()) [2, 3, 4] >>> list(Dataset.range(1, 5, 2).as_numpy_iterator()) [1, 3] >>> list(Dataset.range(1, 5, -2).as_numpy_iterator()) [] >>> list(Dataset.range(5, 1).as_numpy_iterator()) [] >>> list(Dataset.range(5, 1, -2).as_numpy_iterator()) [5, 3] >>> list(Dataset.range(2, 5, output_type=tf.int32).as_numpy_iterator()) [2, 3, 4] >>> list(Dataset.range(1, 5, 2, output_type=tf.float32).as_numpy_iterator()) [1.0, 3.0] Args: *args: follows the same semantics as python's range. len(args) == 1 -> start = 0, stop = args[0], step = 1. len(args) == 2 -> start = args[0], stop = args[1], step = 1. len(args) == 3 -> start = args[0], stop = args[1], step = args[2]. **kwargs: - output_type: Its expected dtype. (Optional, default: `tf.int64`). - name: (Optional.) A name for the tf.data operation. Returns: Dataset: A `RangeDataset`. Raises: ValueError: if len(args) == 0. ) RangeDataset)rr~r>r>r?ranges$zDatasetV2.rangecCs t||dS)a8Creates a `Dataset` by zipping together the given datasets. This method has similar semantics to the built-in `zip()` function in Python, with the main difference being that the `datasets` argument can be a (nested) structure of `Dataset` objects. The supported nesting mechanisms are documented [here] (https://www.tensorflow.org/guide/data#dataset_structure). >>> # The nested structure of the `datasets` argument determines the >>> # structure of elements in the resulting dataset. >>> a = tf.data.Dataset.range(1, 4) # ==> [ 1, 2, 3 ] >>> b = tf.data.Dataset.range(4, 7) # ==> [ 4, 5, 6 ] >>> ds = tf.data.Dataset.zip((a, b)) >>> list(ds.as_numpy_iterator()) [(1, 4), (2, 5), (3, 6)] >>> ds = tf.data.Dataset.zip((b, a)) >>> list(ds.as_numpy_iterator()) [(4, 1), (5, 2), (6, 3)] >>> >>> # The `datasets` argument may contain an arbitrary number of datasets. >>> c = tf.data.Dataset.range(7, 13).batch(2) # ==> [ [7, 8], ... # [9, 10], ... # [11, 12] ] >>> ds = tf.data.Dataset.zip((a, b, c)) >>> for element in ds.as_numpy_iterator(): ... print(element) (1, 4, array([7, 8])) (2, 5, array([ 9, 10])) (3, 6, array([11, 12])) >>> >>> # The number of elements in the resulting dataset is the same as >>> # the size of the smallest dataset in `datasets`. >>> d = tf.data.Dataset.range(13, 15) # ==> [ 13, 14 ] >>> ds = tf.data.Dataset.zip((a, d)) >>> list(ds.as_numpy_iterator()) [(1, 13), (2, 14)] Args: datasets: A (nested) structure of datasets. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. )r=) ZipDataset)datasetsr=r>r>r?rs.z DatasetV2.zipcCst|||dS)aCreates a `Dataset` by concatenating the given dataset with this dataset. >>> a = tf.data.Dataset.range(1, 4) # ==> [ 1, 2, 3 ] >>> b = tf.data.Dataset.range(4, 8) # ==> [ 4, 5, 6, 7 ] >>> ds = a.concatenate(b) >>> list(ds.as_numpy_iterator()) [1, 2, 3, 4, 5, 6, 7] >>> # The input dataset and dataset to be concatenated should have >>> # compatible element specs. >>> c = tf.data.Dataset.zip((a, b)) >>> a.concatenate(c) Traceback (most recent call last): TypeError: Two datasets to concatenate have different types and (tf.int64, tf.int64) >>> d = tf.data.Dataset.from_tensor_slices(["a", "b", "c"]) >>> a.concatenate(d) Traceback (most recent call last): TypeError: Two datasets to concatenate have different types and Args: dataset: `Dataset` to be concatenated. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. )r=)ConcatenateDataset)rVrr=r>r>r? concatenateszDatasetV2.concatenaterrcCsddlm}|j||||dS)a)Creates a `Dataset` that counts from `start` in steps of size `step`. Unlike `tf.data.Dataset.range`, which stops at some ending number, `tf.data.Dataset.counter` produces elements indefinitely. >>> dataset = tf.data.experimental.Counter().take(5) >>> list(dataset.as_numpy_iterator()) [0, 1, 2, 3, 4] >>> dataset.element_spec TensorSpec(shape=(), dtype=tf.int64, name=None) >>> dataset = tf.data.experimental.Counter(dtype=tf.int32) >>> dataset.element_spec TensorSpec(shape=(), dtype=tf.int32, name=None) >>> dataset = tf.data.experimental.Counter(start=2).take(5) >>> list(dataset.as_numpy_iterator()) [2, 3, 4, 5, 6] >>> dataset = tf.data.experimental.Counter(start=2, step=5).take(5) >>> list(dataset.as_numpy_iterator()) [2, 7, 12, 17, 22] >>> dataset = tf.data.experimental.Counter(start=10, step=-1).take(5) >>> list(dataset.as_numpy_iterator()) [10, 9, 8, 7, 6] Args: start: (Optional.) The starting value for the counter. Defaults to 0. step: (Optional.) The step size for the counter. Defaults to 1. dtype: (Optional.) The data type for counter elements. Defaults to `tf.int64`. name: (Optional.) A name for the tf.data operation. Returns: A `Dataset` of scalar `dtype` elements. r) counter_op)r=)rr%counter)startsteprr=r%r>r>r?r& s% zDatasetV2.counterFcCsddlm}|j||||dS)aCreates a `Dataset` that rebatches the elements from this dataset. `rebatch(N)` is functionally equivalent to `unbatch().batch(N)`, but is more efficient, performing one copy instead of two. >>> ds = tf.data.Dataset.range(6) >>> ds = ds.batch(2) >>> ds = ds.rebatch(3) >>> list(ds.as_numpy_iterator()) [array([0, 1, 2]), array([3, 4, 5])] >>> ds = tf.data.Dataset.range(7) >>> ds = ds.batch(4) >>> ds = ds.rebatch(3) >>> list(ds.as_numpy_iterator()) [array([0, 1, 2]), array([3, 4, 5]), array([6])] >>> ds = tf.data.Dataset.range(7) >>> ds = ds.batch(2) >>> ds = ds.rebatch(3, drop_remainder=True) >>> list(ds.as_numpy_iterator()) [array([0, 1, 2]), array([3, 4, 5])] If the `batch_size` argument is a list, `rebatch` cycles through the list to determine the size of each batch. >>> ds = tf.data.Dataset.range(8) >>> ds = ds.batch(4) >>> ds = ds.rebatch([2, 1, 1]) >>> list(ds.as_numpy_iterator()) [array([0, 1]), array([2]), array([3]), array([4, 5]), array([6]), array([7])] Args: batch_size: A `tf.int64` scalar or vector, representing the size of batches to produce. If this argument is a vector, these values are cycled through in round robin fashion. drop_remainder: (Optional.) A `tf.bool` scalar `tf.Tensor`, representing whether the last batch should be dropped in the case it has fewer than `batch_size[cycle_index]` elements; the default behavior is not to drop the smaller batch. name: (Optional.) A name for the tf.data operation. Returns: A `Dataset` of scalar `dtype` elements. r) rebatch_op)r=)rr)rebatch)rV batch_sizedrop_remainderr=r)r>r>r?r*3s1 zDatasetV2.rebatchcCstr|St|||dS)aCreates a `Dataset` that prefetches elements from this dataset. Most dataset input pipelines should end with a call to `prefetch`. This allows later elements to be prepared while the current element is being processed. This often improves latency and throughput, at the cost of using additional memory to store prefetched elements. Note: Like other `Dataset` methods, prefetch operates on the elements of the input dataset. It has no concept of examples vs. batches. `examples.prefetch(2)` will prefetch two elements (2 examples), while `examples.batch(20).prefetch(2)` will prefetch 2 elements (2 batches, of 20 examples each). >>> dataset = tf.data.Dataset.range(3) >>> dataset = dataset.prefetch(2) >>> list(dataset.as_numpy_iterator()) [0, 1, 2] Args: buffer_size: A `tf.int64` scalar `tf.Tensor`, representing the maximum number of elements that will be buffered when prefetching. If the value `tf.data.AUTOTUNE` is used, then the buffer size is dynamically tuned. name: Optional. A name for the tf.data transformation. Returns: A new `Dataset` with the transformation applied as described above. )r=)rPrefetchDataset)rV buffer_sizer=r>r>r?prefetchgszDatasetV2.prefetchc Cs td|dkrd}tj|tjdd}t|}tjt |dddd}tj d t j |d d d d}tj||gd dd}t|gt |}WdQRXddlm}|j|d|d} tttrt| } |rtt j |tjddd } | j| ||d} | SQRXdS)aA dataset of all files matching one or more glob patterns. The `file_pattern` argument should be a small number of glob patterns. If your filenames have already been globbed, use `Dataset.from_tensor_slices(filenames)` instead, as re-globbing every filename with `list_files` may result in poor performance with remote storage systems. Note: The default behavior of this method is to return filenames in a non-deterministic random shuffled order. Pass a `seed` or `shuffle=False` to get results in a deterministic order. Example: If we had the following files on our filesystem: - /path/to/dir/a.txt - /path/to/dir/b.py - /path/to/dir/c.py If we pass "/path/to/dir/*.py" as the directory, the dataset would produce: - /path/to/dir/b.py - /path/to/dir/c.py Args: file_pattern: A string, a list of strings, or a `tf.Tensor` of string type (scalar or vector), representing the filename glob (i.e. shell wildcard) pattern(s) that will be matched. shuffle: (Optional.) If `True`, the file names will be shuffled randomly. Defaults to `True`. seed: (Optional.) A `tf.int64` scalar `tf.Tensor`, representing the random seed that will be used to create the distribution. See `tf.random.set_seed` for behavior. name: Optional. A name for the tf.data operations used by `list_files`. Returns: Dataset: A `Dataset` of strings corresponding to file names. list_filesNT file_pattern)rr=rZmatch_not_empty)r=zNo files matched pattern: z, ) separatormessagerassert_not_empty) summarizer=)r)Zis_filesr=)Zout_type)seedr=)r name_scopeconvert_to_tensorrror matching_filesr#Zgreaterrraddr&Z reduce_joinrAssertcontrol_dependenciesidentityrrZTensorSliceDataset issubclassrrQrmaximumrshuffle) r1r@r6r=r9 conditionr3r4rrr.r>r>r?r0s2)     zDatasetV2.list_filescCst|||dS)adRepeats this dataset so each original value is seen `count` times. >>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3]) >>> dataset = dataset.repeat(3) >>> list(dataset.as_numpy_iterator()) [1, 2, 3, 1, 2, 3, 1, 2, 3] Note: If the input dataset depends on global state (e.g. a random number generator) or its output is non-deterministic (e.g. because of upstream `shuffle`), then different repetitions may produce different elements. Args: count: (Optional.) A `tf.int64` scalar `tf.Tensor`, representing the number of times the dataset should be repeated. The default behavior (if `count` is `None` or `-1`) is for the dataset be repeated indefinitely. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. )r=) RepeatDataset)rVcountr=r>r>r?repeatszDatasetV2.repeatcCs<ttjjj}tj|||d}t|d}tj ||f|dS)aEnumerates the elements of this dataset. It is similar to python's `enumerate`. >>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3]) >>> dataset = dataset.enumerate(start=5) >>> for element in dataset.as_numpy_iterator(): ... print(element) (5, 1) (6, 2) (7, 3) >>> # The (nested) structure of the input dataset determines the >>> # structure of elements in the resulting dataset. >>> dataset = tf.data.Dataset.from_tensor_slices([(7, 8), (9, 10)]) >>> dataset = dataset.enumerate() >>> for element in dataset.as_numpy_iterator(): ... print(element) (0, array([7, 8], dtype=int32)) (1, array([ 9, 10], dtype=int32)) Args: start: A `tf.int64` scalar `tf.Tensor`, representing the start value for enumeration. name: Optional. A name for the tf.data operations used by `enumerate`. Returns: A new `Dataset` with the transformation applied as described above. )r=replicate_on_split) riinforrrmaxrr _apply_rewriter)rVr'r=Z max_value range_datasetr>r>r?rqs zDatasetV2.enumeratecCst|||||dS)a Randomly shuffles the elements of this dataset. This dataset fills a buffer with `buffer_size` elements, then randomly samples elements from this buffer, replacing the selected elements with new elements. For perfect shuffling, a buffer size greater than or equal to the full size of the dataset is required. For instance, if your dataset contains 10,000 elements but `buffer_size` is set to 1,000, then `shuffle` will initially select a random element from only the first 1,000 elements in the buffer. Once an element is selected, its space in the buffer is replaced by the next (i.e. 1,001-st) element, maintaining the 1,000 element buffer. `reshuffle_each_iteration` controls whether the shuffle order should be different for each epoch. In TF 1.X, the idiomatic way to create epochs was through the `repeat` transformation: ```python dataset = tf.data.Dataset.range(3) dataset = dataset.shuffle(3, reshuffle_each_iteration=True) dataset = dataset.repeat(2) # [1, 0, 2, 1, 2, 0] dataset = tf.data.Dataset.range(3) dataset = dataset.shuffle(3, reshuffle_each_iteration=False) dataset = dataset.repeat(2) # [1, 0, 2, 1, 0, 2] ``` In TF 2.0, `tf.data.Dataset` objects are Python iterables which makes it possible to also create epochs through Python iteration: ```python dataset = tf.data.Dataset.range(3) dataset = dataset.shuffle(3, reshuffle_each_iteration=True) list(dataset.as_numpy_iterator()) # [1, 0, 2] list(dataset.as_numpy_iterator()) # [1, 2, 0] ``` ```python dataset = tf.data.Dataset.range(3) dataset = dataset.shuffle(3, reshuffle_each_iteration=False) list(dataset.as_numpy_iterator()) # [1, 0, 2] list(dataset.as_numpy_iterator()) # [1, 0, 2] ``` Args: buffer_size: A `tf.int64` scalar `tf.Tensor`, representing the number of elements from this dataset from which the new dataset will sample. seed: (Optional.) A `tf.int64` scalar `tf.Tensor`, representing the random seed that will be used to create the distribution. See `tf.random.set_seed` for behavior. reshuffle_each_iteration: (Optional.) A boolean, which if true indicates that the dataset should be pseudorandomly reshuffled each time it is iterated over. (Defaults to `True`.) name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. )r=)ShuffleDataset)rVr.r6reshuffle_each_iterationr=r>r>r?r@sEzDatasetV2.shufflecCst|||dS)a Caches the elements in this dataset. The first time the dataset is iterated over, its elements will be cached either in the specified file or in memory. Subsequent iterations will use the cached data. Note: To guarantee that the cache gets finalized, the input dataset must be iterated through in its entirety, until it raises StopIteration. Otherwise, subsequent iterations may not use cached data. >>> dataset = tf.data.Dataset.range(5) >>> dataset = dataset.map(lambda x: x**2) >>> dataset = dataset.cache() >>> # The first time reading through the data will generate the data using >>> # `range` and `map`. >>> list(dataset.as_numpy_iterator()) [0, 1, 4, 9, 16] >>> # Subsequent iterations read from the cache. >>> list(dataset.as_numpy_iterator()) [0, 1, 4, 9, 16] When caching to a file, the cached data will persist across runs. Even the first iteration through the data will read from the cache file. Changing the input pipeline before the call to `.cache()` will have no effect until the cache file is removed or the filename is changed. ```python dataset = tf.data.Dataset.range(5) dataset = dataset.cache("/path/to/file") list(dataset.as_numpy_iterator()) # [0, 1, 2, 3, 4] dataset = tf.data.Dataset.range(10) dataset = dataset.cache("/path/to/file") # Same file! list(dataset.as_numpy_iterator()) # [0, 1, 2, 3, 4] ``` Note: `cache` will produce exactly the same elements during each iteration through the dataset. If you wish to randomize the iteration order, make sure to call `shuffle` *after* calling `cache`. Args: filename: A `tf.string` scalar `tf.Tensor`, representing the name of a directory on the filesystem to use for caching elements in this Dataset. If a filename is not provided, the dataset will be cached in memory. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. )r=) CacheDataset)rVfilenamer=r>r>r?cacheZs3zDatasetV2.cachecCst|||dS)aCreates a `Dataset` with at most `count` elements from this dataset. >>> dataset = tf.data.Dataset.range(10) >>> dataset = dataset.take(3) >>> list(dataset.as_numpy_iterator()) [0, 1, 2] Args: count: A `tf.int64` scalar `tf.Tensor`, representing the number of elements of this dataset that should be taken to form the new dataset. If `count` is -1, or if `count` is greater than the size of this dataset, the new dataset will contain all elements of this dataset. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. )r=) TakeDataset)rVrCr=r>r>r?takeszDatasetV2.takecCst|||dS)aCreates a `Dataset` that skips `count` elements from this dataset. >>> dataset = tf.data.Dataset.range(10) >>> dataset = dataset.skip(7) >>> list(dataset.as_numpy_iterator()) [7, 8, 9] Args: count: A `tf.int64` scalar `tf.Tensor`, representing the number of elements of this dataset that should be skipped to form the new dataset. If `count` is greater than the size of this dataset, the new dataset will contain no elements. If `count` is -1, skips the entire dataset. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. )r=) SkipDataset)rVrCr=r>r>r?skipszDatasetV2.skipcCst||||dS)a Creates a `Dataset` that includes only 1/`num_shards` of this dataset. `shard` is deterministic. The Dataset produced by `A.shard(n, i)` will contain all elements of A whose index mod n = i. >>> A = tf.data.Dataset.range(10) >>> B = A.shard(num_shards=3, index=0) >>> list(B.as_numpy_iterator()) [0, 3, 6, 9] >>> C = A.shard(num_shards=3, index=1) >>> list(C.as_numpy_iterator()) [1, 4, 7] >>> D = A.shard(num_shards=3, index=2) >>> list(D.as_numpy_iterator()) [2, 5, 8] This dataset operator is very useful when running distributed training, as it allows each worker to read a unique subset. When reading a single input file, you can shard elements as follows: ```python d = tf.data.TFRecordDataset(input_file) d = d.shard(num_workers, worker_index) d = d.repeat(num_epochs) d = d.shuffle(shuffle_buffer_size) d = d.map(parser_fn, num_parallel_calls=num_map_threads) ``` Important caveats: - Be sure to shard before you use any randomizing operator (such as shuffle). - Generally it is best if the shard operator is used early in the dataset pipeline. For example, when reading from a set of TFRecord files, shard before converting the dataset to input samples. This avoids reading every file on every worker. The following is an example of an efficient sharding strategy within a complete pipeline: ```python d = Dataset.list_files(pattern) d = d.shard(num_workers, worker_index) d = d.repeat(num_epochs) d = d.shuffle(shuffle_buffer_size) d = d.interleave(tf.data.TFRecordDataset, cycle_length=num_readers, block_length=1) d = d.map(parser_fn, num_parallel_calls=num_map_threads) ``` Args: num_shards: A `tf.int64` scalar `tf.Tensor`, representing the number of shards operating in parallel. index: A `tf.int64` scalar `tf.Tensor`, representing the worker index. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. Raises: InvalidArgumentError: if `num_shards` or `index` are illegal values. Note: error checking is done on a best-effort basis, and errors aren't guaranteed to be caught upon dataset creation. (e.g. providing in a placeholder tensor bypasses the early checking, and will instead result in an error during a session.run call.) )r=) ShardDataset)rV num_shardsindexr=r>r>r?shardsCzDatasetV2.shardcCs"ddlm}||||||dS)a Saves the content of the given dataset. Example usage: >>> import tempfile >>> path = os.path.join(tempfile.gettempdir(), "saved_data") >>> # Save a dataset >>> dataset = tf.data.Dataset.range(2) >>> dataset.save(path) >>> new_dataset = tf.data.Dataset.load(path) >>> for elem in new_dataset: ... print(elem) tf.Tensor(0, shape=(), dtype=int64) tf.Tensor(1, shape=(), dtype=int64) The saved dataset is saved in multiple file "shards". By default, the dataset output is divided to shards in a round-robin fashion but custom sharding can be specified via the `shard_func` function. For example, you can save the dataset to using a single shard as follows: ```python dataset = make_dataset() def custom_shard_func(element): return np.int64(0) dataset.save( path="/path/to/data", ..., shard_func=custom_shard_func) ``` To enable checkpointing, pass in `checkpoint_args` to the `save` method as follows: ```python dataset = tf.data.Dataset.range(100) save_dir = "..." checkpoint_prefix = "..." step_counter = tf.Variable(0, trainable=False) checkpoint_args = { "checkpoint_interval": 50, "step_counter": step_counter, "directory": checkpoint_prefix, "max_to_keep": 20, } dataset.save(dataset, save_dir, checkpoint_args=checkpoint_args) ``` NOTE: The directory layout and file format used for saving the dataset is considered an implementation detail and may change. For this reason, datasets saved through `tf.data.Dataset.save` should only be consumed through `tf.data.Dataset.load`, which is guaranteed to be backwards compatible. Args: path: Required. A directory to use for saving the dataset. compression: Optional. The algorithm to use to compress data when writing it. Supported options are `GZIP` and `NONE`. Defaults to `NONE`. shard_func: Optional. A function to control the mapping of dataset elements to file shards. The function is expected to map elements of the input dataset to int64 shard IDs. If present, the function will be traced and executed as graph computation. checkpoint_args: Optional args for checkpointing which will be passed into the `tf.train.CheckpointManager`. If `checkpoint_args` are not specified, then checkpointing will not be performed. The `save()` implementation creates a `tf.train.Checkpoint` object internally, so users should not set the `checkpoint` argument in `checkpoint_args`. Raises: ValueError if `checkpoint` is passed into `checkpoint_args`. r)save_opN)rrXsave)rVpath compression shard_funcZcheckpoint_argsrXr>r>r?rYsK zDatasetV2.savecCsddlm}|j||||dS)aC Loads a previously saved dataset. Example usage: >>> import tempfile >>> path = os.path.join(tempfile.gettempdir(), "saved_data") >>> # Save a dataset >>> dataset = tf.data.Dataset.range(2) >>> tf.data.Dataset.save(dataset, path) >>> new_dataset = tf.data.Dataset.load(path) >>> for elem in new_dataset: ... print(elem) tf.Tensor(0, shape=(), dtype=int64) tf.Tensor(1, shape=(), dtype=int64) If the default option of sharding the saved dataset was used, the element order of the saved dataset will be preserved when loading it. The `reader_func` argument can be used to specify a custom order in which elements should be loaded from the individual shards. The `reader_func` is expected to take a single argument -- a dataset of datasets, each containing elements of one of the shards -- and return a dataset of elements. For example, the order of shards can be shuffled when loading them as follows: ```python def custom_reader_func(datasets): datasets = datasets.shuffle(NUM_SHARDS) return datasets.interleave(lambda x: x, num_parallel_calls=AUTOTUNE) dataset = tf.data.Dataset.load( path="/path/to/data", ..., reader_func=custom_reader_func) ``` Args: path: Required. A path pointing to a previously saved dataset. element_spec: Optional. A nested structure of `tf.TypeSpec` objects matching the structure of an element of the saved dataset and specifying the type of individual element components. If not provided, the nested structure of `tf.TypeSpec` saved with the saved dataset is used. Note that this argument is required in graph mode. compression: Optional. The algorithm to use to decompress the data when reading it. Supported options are `GZIP` and `NONE`. Defaults to `NONE`. reader_func: Optional. A function to control how to read data from shards. If present, the function will be traced and executed as graph computation. Returns: A `tf.data.Dataset` instance. Raises: FileNotFoundError: If `element_spec` is not specified and the saved nested structure of `tf.TypeSpec` can not be located with the saved dataset. ValueError: If `element_spec` is not specified and the method is executed in graph mode. r)load_op)rZrr[ reader_func)rr]load)rZrr[r^r]r>r>r?r_Js < zDatasetV2.loadcCsJ|dks tr2|dk r"ts"tdt||||dSt||||||dSdS)a Combines consecutive elements of this dataset into batches. >>> dataset = tf.data.Dataset.range(8) >>> dataset = dataset.batch(3) >>> list(dataset.as_numpy_iterator()) [array([0, 1, 2]), array([3, 4, 5]), array([6, 7])] >>> dataset = tf.data.Dataset.range(8) >>> dataset = dataset.batch(3, drop_remainder=True) >>> list(dataset.as_numpy_iterator()) [array([0, 1, 2]), array([3, 4, 5])] The components of the resulting element will have an additional outer dimension, which will be `batch_size` (or `N % batch_size` for the last element if `batch_size` does not divide the number of input elements `N` evenly and `drop_remainder` is `False`). If your program depends on the batches having the same outer dimension, you should set the `drop_remainder` argument to `True` to prevent the smaller batch from being produced. Note: If your program requires data to have a statically known shape (e.g., when using XLA), you should use `drop_remainder=True`. Without `drop_remainder=True` the shape of the output dataset will have an unknown leading dimension due to the possibility of a smaller final batch. Args: batch_size: A `tf.int64` scalar `tf.Tensor`, representing the number of consecutive elements of this dataset to combine in a single batch. drop_remainder: (Optional.) A `tf.bool` scalar `tf.Tensor`, representing whether the last batch should be dropped in the case it has fewer than `batch_size` elements; the default behavior is not to drop the smaller batch. num_parallel_calls: (Optional.) A `tf.int64` scalar `tf.Tensor`, representing the number of batches to compute asynchronously in parallel. If not specified, batches will be computed sequentially. If the value `tf.data.AUTOTUNE` is used, then the number of parallel calls is set dynamically based on available resources. deterministic: (Optional.) When `num_parallel_calls` is specified, if this boolean is specified (`True` or `False`), it controls the order in which the transformation produces elements. If set to `False`, the transformation is allowed to yield elements out of order to trade determinism for performance. If not specified, the `tf.data.Options.deterministic` option (`True` by default) controls the behavior. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. NzaThe `deterministic` argument has no effect unless the `num_parallel_calls` argument is specified.)r=)rrr BatchDatasetParallelBatchDataset)rVr+r,num_parallel_calls deterministicr=r>r>r?batchs7   zDatasetV2.batchcCsT|dkr@t|}x.tt|D]\}}|s td|dq Wt||||||dS)a^Combines consecutive elements of this dataset into padded batches. This transformation combines multiple consecutive elements of the input dataset into a single element. Like `tf.data.Dataset.batch`, the components of the resulting element will have an additional outer dimension, which will be `batch_size` (or `N % batch_size` for the last element if `batch_size` does not divide the number of input elements `N` evenly and `drop_remainder` is `False`). If your program depends on the batches having the same outer dimension, you should set the `drop_remainder` argument to `True` to prevent the smaller batch from being produced. Unlike `tf.data.Dataset.batch`, the input elements to be batched may have different shapes, and this transformation will pad each component to the respective shape in `padded_shapes`. The `padded_shapes` argument determines the resulting shape for each dimension of each component in an output element: * If the dimension is a constant, the component will be padded out to that length in that dimension. * If the dimension is unknown, the component will be padded out to the maximum length of all elements in that dimension. >>> A = (tf.data.Dataset ... .range(1, 5, output_type=tf.int32) ... .map(lambda x: tf.fill([x], x))) >>> # Pad to the smallest per-batch size that fits all elements. >>> B = A.padded_batch(2) >>> for element in B.as_numpy_iterator(): ... print(element) [[1 0] [2 2]] [[3 3 3 0] [4 4 4 4]] >>> # Pad to a fixed size. >>> C = A.padded_batch(2, padded_shapes=5) >>> for element in C.as_numpy_iterator(): ... print(element) [[1 0 0 0 0] [2 2 0 0 0]] [[3 3 3 0 0] [4 4 4 4 0]] >>> # Pad with a custom value. >>> D = A.padded_batch(2, padded_shapes=5, padding_values=-1) >>> for element in D.as_numpy_iterator(): ... print(element) [[ 1 -1 -1 -1 -1] [ 2 2 -1 -1 -1]] [[ 3 3 3 -1 -1] [ 4 4 4 4 -1]] >>> # Components of nested elements can be padded independently. >>> elements = [([1, 2, 3], [10]), ... ([4, 5], [11, 12])] >>> dataset = tf.data.Dataset.from_generator( ... lambda: iter(elements), (tf.int32, tf.int32)) >>> # Pad the first component of the tuple to length 4, and the second >>> # component to the smallest size that fits. >>> dataset = dataset.padded_batch(2, ... padded_shapes=([4], [None]), ... padding_values=(-1, 100)) >>> list(dataset.as_numpy_iterator()) [(array([[ 1, 2, 3, -1], [ 4, 5, -1, -1]], dtype=int32), array([[ 10, 100], [ 11, 12]], dtype=int32))] >>> # Pad with a single value and multiple components. >>> E = tf.data.Dataset.zip((A, A)).padded_batch(2, padding_values=-1) >>> for element in E.as_numpy_iterator(): ... print(element) (array([[ 1, -1], [ 2, 2]], dtype=int32), array([[ 1, -1], [ 2, 2]], dtype=int32)) (array([[ 3, 3, 3, -1], [ 4, 4, 4, 4]], dtype=int32), array([[ 3, 3, 3, -1], [ 4, 4, 4, 4]], dtype=int32)) See also `tf.data.experimental.dense_to_sparse_batch`, which combines elements that may have different shapes into a `tf.sparse.SparseTensor`. Args: batch_size: A `tf.int64` scalar `tf.Tensor`, representing the number of consecutive elements of this dataset to combine in a single batch. padded_shapes: (Optional.) A (nested) structure of `tf.TensorShape` or `tf.int64` vector tensor-like objects representing the shape to which the respective component of each input element should be padded prior to batching. Any unknown dimensions will be padded to the maximum size of that dimension in each batch. If unset, all dimensions of all components are padded to the maximum size in the batch. `padded_shapes` must be set if any component has an unknown rank. padding_values: (Optional.) A (nested) structure of scalar-shaped `tf.Tensor`, representing the padding values to use for the respective components. None represents that the (nested) structure should be padded with default values. Defaults are `0` for numeric types and the empty string for string types. The `padding_values` should have the same (nested) structure as the input dataset. If `padding_values` is a single element and the input dataset has multiple components, then the same `padding_values` will be used to pad every component of the dataset. If `padding_values` is a scalar, then its value will be broadcasted to match the shape of each component. drop_remainder: (Optional.) A `tf.bool` scalar `tf.Tensor`, representing whether the last batch should be dropped in the case it has fewer than `batch_size` elements; the default behavior is not to drop the smaller batch. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. Raises: ValueError: If a component has an unknown rank, and the `padded_shapes` argument is not set. TypeError: If a component is of an unsupported type. The list of supported types is documented in https://www.tensorflow.org/guide/data#dataset_structure. Nzr>r? padded_batchsxzDatasetV2.padded_batchcCsJ|dks tr2|dk r"ts"tdt||d|dSt||||d|dSdS)aMaps `map_func` across the elements of this dataset. This transformation applies `map_func` to each element of this dataset, and returns a new dataset containing the transformed elements, in the same order as they appeared in the input. `map_func` can be used to change both the values and the structure of a dataset's elements. Supported structure constructs are documented [here](https://www.tensorflow.org/guide/data#dataset_structure). For example, `map` can be used for adding 1 to each element, or projecting a subset of element components. >>> dataset = Dataset.range(1, 6) # ==> [ 1, 2, 3, 4, 5 ] >>> dataset = dataset.map(lambda x: x + 1) >>> list(dataset.as_numpy_iterator()) [2, 3, 4, 5, 6] The input signature of `map_func` is determined by the structure of each element in this dataset. >>> dataset = Dataset.range(5) >>> # `map_func` takes a single argument of type `tf.Tensor` with the same >>> # shape and dtype. >>> result = dataset.map(lambda x: x + 1) >>> # Each element is a tuple containing two `tf.Tensor` objects. >>> elements = [(1, "foo"), (2, "bar"), (3, "baz")] >>> dataset = tf.data.Dataset.from_generator( ... lambda: elements, (tf.int32, tf.string)) >>> # `map_func` takes two arguments of type `tf.Tensor`. This function >>> # projects out just the first component. >>> result = dataset.map(lambda x_int, y_str: x_int) >>> list(result.as_numpy_iterator()) [1, 2, 3] >>> # Each element is a dictionary mapping strings to `tf.Tensor` objects. >>> elements = ([{"a": 1, "b": "foo"}, ... {"a": 2, "b": "bar"}, ... {"a": 3, "b": "baz"}]) >>> dataset = tf.data.Dataset.from_generator( ... lambda: elements, {"a": tf.int32, "b": tf.string}) >>> # `map_func` takes a single argument of type `dict` with the same keys >>> # as the elements. >>> result = dataset.map(lambda d: str(d["a"]) + d["b"]) The value or values returned by `map_func` determine the structure of each element in the returned dataset. >>> dataset = tf.data.Dataset.range(3) >>> # `map_func` returns two `tf.Tensor` objects. >>> def g(x): ... return tf.constant(37.0), tf.constant(["Foo", "Bar", "Baz"]) >>> result = dataset.map(g) >>> result.element_spec (TensorSpec(shape=(), dtype=tf.float32, name=None), TensorSpec(shape=(3,), dtype=tf.string, name=None)) >>> # Python primitives, lists, and NumPy arrays are implicitly converted to >>> # `tf.Tensor`. >>> def h(x): ... return 37.0, ["Foo", "Bar"], np.array([1.0, 2.0], dtype=np.float64) >>> result = dataset.map(h) >>> result.element_spec (TensorSpec(shape=(), dtype=tf.float32, name=None), TensorSpec(shape=(2,), dtype=tf.string, name=None), TensorSpec(shape=(2,), dtype=tf.float64, name=None)) >>> # `map_func` can return nested structures. >>> def i(x): ... return (37.0, [42, 16]), "foo" >>> result = dataset.map(i) >>> result.element_spec ((TensorSpec(shape=(), dtype=tf.float32, name=None), TensorSpec(shape=(2,), dtype=tf.int32, name=None)), TensorSpec(shape=(), dtype=tf.string, name=None)) `map_func` can accept as arguments and return any type of dataset element. Note that irrespective of the context in which `map_func` is defined (eager vs. graph), tf.data traces the function and executes it as a graph. To use Python code inside of the function you have a few options: 1) Rely on AutoGraph to convert Python code into an equivalent graph computation. The downside of this approach is that AutoGraph can convert some but not all Python code. 2) Use `tf.py_function`, which allows you to write arbitrary Python code but will generally result in worse performance than 1). For example: >>> d = tf.data.Dataset.from_tensor_slices(['hello', 'world']) >>> # transform a string tensor to upper case string using a Python function >>> def upper_case_fn(t: tf.Tensor): ... return t.numpy().decode('utf-8').upper() >>> d = d.map(lambda x: tf.py_function(func=upper_case_fn, ... inp=[x], Tout=tf.string)) >>> list(d.as_numpy_iterator()) [b'HELLO', b'WORLD'] 3) Use `tf.numpy_function`, which also allows you to write arbitrary Python code. Note that `tf.py_function` accepts `tf.Tensor` whereas `tf.numpy_function` accepts numpy arrays and returns only numpy arrays. For example: >>> d = tf.data.Dataset.from_tensor_slices(['hello', 'world']) >>> def upper_case_fn(t: np.ndarray): ... return t.decode('utf-8').upper() >>> d = d.map(lambda x: tf.numpy_function(func=upper_case_fn, ... inp=[x], Tout=tf.string)) >>> list(d.as_numpy_iterator()) [b'HELLO', b'WORLD'] Note that the use of `tf.numpy_function` and `tf.py_function` in general precludes the possibility of executing user-defined transformations in parallel (because of Python GIL). Performance can often be improved by setting `num_parallel_calls` so that `map` will use multiple threads to process elements. If deterministic order isn't required, it can also improve performance to set `deterministic=False`. >>> dataset = Dataset.range(1, 6) # ==> [ 1, 2, 3, 4, 5 ] >>> dataset = dataset.map(lambda x: x + 1, ... num_parallel_calls=tf.data.AUTOTUNE, ... deterministic=False) The order of elements yielded by this transformation is deterministic if `deterministic=True`. If `map_func` contains stateful operations and `num_parallel_calls > 1`, the order in which that state is accessed is undefined, so the values of output elements may not be deterministic regardless of the `deterministic` flag value. Args: map_func: A function mapping a dataset element to another dataset element. num_parallel_calls: (Optional.) A `tf.int64` scalar `tf.Tensor`, representing the number elements to process asynchronously in parallel. If not specified, elements will be processed sequentially. If the value `tf.data.AUTOTUNE` is used, then the number of parallel calls is set dynamically based on available CPU. deterministic: (Optional.) When `num_parallel_calls` is specified, if this boolean is specified (`True` or `False`), it controls the order in which the transformation produces elements. If set to `False`, the transformation is allowed to yield elements out of order to trade determinism for performance. If not specified, the `tf.data.Options.deterministic` option (`True` by default) controls the behavior. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. NzaThe `deterministic` argument has no effect unless the `num_parallel_calls` argument is specified.T)preserve_cardinalityr=)rrr MapDatasetParallelMapDataset)rVmap_funcrbrcr=r>r>r?mapYs   z DatasetV2.mapcCst|||dS)a Maps `map_func` across this dataset and flattens the result. The type signature is: ``` def flat_map( self: Dataset[T], map_func: Callable[[T], Dataset[S]] ) -> Dataset[S] ``` Use `flat_map` if you want to make sure that the order of your dataset stays the same. For example, to flatten a dataset of batches into a dataset of their elements: >>> dataset = tf.data.Dataset.from_tensor_slices( ... [[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> dataset = dataset.flat_map(tf.data.Dataset.from_tensor_slices) >>> list(dataset.as_numpy_iterator()) [1, 2, 3, 4, 5, 6, 7, 8, 9] `tf.data.Dataset.interleave()` is a generalization of `flat_map`, since `flat_map` produces the same output as `tf.data.Dataset.interleave(cycle_length=1)` Args: map_func: A function mapping a dataset element to a dataset. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. )r=)FlatMapDataset)rVrmr=r>r>r?r s!zDatasetV2.flat_mapcCsddlm}||||S)aDrops elements that cause errors. >>> dataset = tf.data.Dataset.from_tensor_slices([1., 2., 0., 4.]) >>> dataset = dataset.map(lambda x: tf.debugging.check_numerics(1. / x, "")) >>> list(dataset.as_numpy_iterator()) Traceback (most recent call last): ... InvalidArgumentError: ... Tensor had Inf values >>> dataset = dataset.ignore_errors() >>> list(dataset.as_numpy_iterator()) [1.0, 0.5, 0.25] Args: log_warning: (Optional.) A bool indicating whether or not ignored errors should be logged to stderr. Defaults to `False`. name: (Optional.) A string indicating a name for the `tf.data` operation. Returns: A new `Dataset` with the transformation applied as described above. r)ignore_errors_op)rrp ignore_errors)rVZ log_warningr=rpr>r>r?rq# s zDatasetV2.ignore_errorsc Csf|dkr d}|dkrt}|dks$trL|dk r:ts:tdt|||||dSt|||||||dSdS)aMaps `map_func` across this dataset, and interleaves the results. The type signature is: ``` def interleave( self: Dataset[T], map_func: Callable[[T], Dataset[S]] ) -> Dataset[S] ``` For example, you can use `Dataset.interleave()` to process many input files concurrently: >>> # Preprocess 4 files concurrently, and interleave blocks of 16 records >>> # from each file. >>> filenames = ["/var/data/file1.txt", "/var/data/file2.txt", ... "/var/data/file3.txt", "/var/data/file4.txt"] >>> dataset = tf.data.Dataset.from_tensor_slices(filenames) >>> def parse_fn(filename): ... return tf.data.Dataset.range(10) >>> dataset = dataset.interleave(lambda x: ... tf.data.TextLineDataset(x).map(parse_fn, num_parallel_calls=1), ... cycle_length=4, block_length=16) The `cycle_length` and `block_length` arguments control the order in which elements are produced. `cycle_length` controls the number of input elements that are processed concurrently. If you set `cycle_length` to 1, this transformation will handle one input element at a time, and will produce identical results to `tf.data.Dataset.flat_map`. In general, this transformation will apply `map_func` to `cycle_length` input elements, open iterators on the returned `Dataset` objects, and cycle through them producing `block_length` consecutive elements from each iterator, and consuming the next input element each time it reaches the end of an iterator. For example: >>> dataset = Dataset.range(1, 6) # ==> [ 1, 2, 3, 4, 5 ] >>> # NOTE: New lines indicate "block" boundaries. >>> dataset = dataset.interleave( ... lambda x: Dataset.from_tensors(x).repeat(6), ... cycle_length=2, block_length=4) >>> list(dataset.as_numpy_iterator()) [1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 3, 3, 4, 4, 5, 5, 5, 5, 5, 5] Note: The order of elements yielded by this transformation is deterministic, as long as `map_func` is a pure function and `deterministic=True`. If `map_func` contains any stateful operations, the order in which that state is accessed is undefined. Performance can often be improved by setting `num_parallel_calls` so that `interleave` will use multiple threads to fetch elements. If determinism isn't required, it can also improve performance to set `deterministic=False`. >>> filenames = ["/var/data/file1.txt", "/var/data/file2.txt", ... "/var/data/file3.txt", "/var/data/file4.txt"] >>> dataset = tf.data.Dataset.from_tensor_slices(filenames) >>> dataset = dataset.interleave(lambda x: tf.data.TFRecordDataset(x), ... cycle_length=4, num_parallel_calls=tf.data.AUTOTUNE, ... deterministic=False) Args: map_func: A function that takes a dataset element and returns a `tf.data.Dataset`. cycle_length: (Optional.) The number of input elements that will be processed concurrently. If not set, the tf.data runtime decides what it should be based on available CPU. If `num_parallel_calls` is set to `tf.data.AUTOTUNE`, the `cycle_length` argument identifies the maximum degree of parallelism. block_length: (Optional.) The number of consecutive elements to produce from each input element before cycling to another input element. If not set, defaults to 1. num_parallel_calls: (Optional.) If specified, the implementation creates a threadpool, which is used to fetch inputs from cycle elements asynchronously and in parallel. The default behavior is to fetch inputs from cycle elements synchronously with no parallelism. If the value `tf.data.AUTOTUNE` is used, then the number of parallel calls is set dynamically based on available CPU. deterministic: (Optional.) When `num_parallel_calls` is specified, if this boolean is specified (`True` or `False`), it controls the order in which the transformation produces elements. If set to `False`, the transformation is allowed to yield elements out of order to trade determinism for performance. If not specified, the `tf.data.Options.deterministic` option (`True` by default) controls the behavior. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. NrzaThe `deterministic` argument has no effect unless the `num_parallel_calls` argument is specified.)r=)rcr=)r5rrrInterleaveDatasetParallelInterleaveDataset)rVrm cycle_length block_lengthrbrcr=r>r>r? interleave= s"l   zDatasetV2.interleavecCsddlm}||||S)aFilters this dataset according to `predicate`. >>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3]) >>> dataset = dataset.filter(lambda x: x < 3) >>> list(dataset.as_numpy_iterator()) [1, 2] >>> # `tf.math.equal(x, y)` is required for equality comparison >>> def filter_fn(x): ... return tf.math.equal(x, 1) >>> dataset = dataset.filter(filter_fn) >>> list(dataset.as_numpy_iterator()) [1] Args: predicate: A function mapping a dataset element to a boolean. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. r) filter_op)rrwfilter)rV predicater=rwr>r>r?rx s zDatasetV2.filtercCs2||}t|ts&tdt|d|g|_|S)aApplies a transformation function to this dataset. `apply` enables chaining of custom `Dataset` transformations, which are represented as functions that take one `Dataset` argument and return a transformed `Dataset`. >>> dataset = tf.data.Dataset.range(100) >>> def dataset_fn(ds): ... return ds.filter(lambda x: x < 5) >>> dataset = dataset.apply(dataset_fn) >>> list(dataset.as_numpy_iterator()) [0, 1, 2, 3, 4] Args: transformation_func: A function that takes one `Dataset` argument and returns a `Dataset`. Returns: A new `Dataset` with the transformation applied as described above. zB`transformation_func` must return a `tf.data.Dataset` object. Got rI)rArGrSrD_input_datasets)rVtransformation_funcrr>r>r?apply s  zDatasetV2.applycCs |dkr |}t||||||dS)aReturns a dataset of "windows". Each "window" is a dataset that contains a subset of elements of the input dataset. These are finite datasets of size `size` (or possibly fewer if there are not enough input elements to fill the window and `drop_remainder` evaluates to `False`). For example: >>> dataset = tf.data.Dataset.range(7).window(3) >>> for window in dataset: ... print(window) <...Dataset element_spec=TensorSpec(shape=(), dtype=tf.int64, name=None)> <...Dataset element_spec=TensorSpec(shape=(), dtype=tf.int64, name=None)> <...Dataset element_spec=TensorSpec(shape=(), dtype=tf.int64, name=None)> Since windows are datasets, they can be iterated over: >>> for window in dataset: ... print(list(window.as_numpy_iterator())) [0, 1, 2] [3, 4, 5] [6] #### Shift The `shift` argument determines the number of input elements to shift between the start of each window. If windows and elements are both numbered starting at 0, the first element in window `k` will be element `k * shift` of the input dataset. In particular, the first element of the first window will always be the first element of the input dataset. >>> dataset = tf.data.Dataset.range(7).window(3, shift=1, ... drop_remainder=True) >>> for window in dataset: ... print(list(window.as_numpy_iterator())) [0, 1, 2] [1, 2, 3] [2, 3, 4] [3, 4, 5] [4, 5, 6] #### Stride The `stride` argument determines the stride between input elements within a window. >>> dataset = tf.data.Dataset.range(7).window(3, shift=1, stride=2, ... drop_remainder=True) >>> for window in dataset: ... print(list(window.as_numpy_iterator())) [0, 2, 4] [1, 3, 5] [2, 4, 6] #### Nested elements When the `window` transformation is applied to a dataset whos elements are nested structures, it produces a dataset where the elements have the same nested structure but each leaf is replaced by a window. In other words, the nesting is applied outside of the windows as opposed inside of them. The type signature is: ``` def window( self: Dataset[Nest[T]], ... ) -> Dataset[Nest[Dataset[T]]] ``` Applying `window` to a `Dataset` of tuples gives a tuple of windows: >>> dataset = tf.data.Dataset.from_tensor_slices(([1, 2, 3, 4, 5], ... [6, 7, 8, 9, 10])) >>> dataset = dataset.window(2) >>> windows = next(iter(dataset)) >>> windows (<...Dataset element_spec=TensorSpec(shape=(), dtype=tf.int32, name=None)>, <...Dataset element_spec=TensorSpec(shape=(), dtype=tf.int32, name=None)>) >>> def to_numpy(ds): ... return list(ds.as_numpy_iterator()) >>> >>> for windows in dataset: ... print(to_numpy(windows[0]), to_numpy(windows[1])) [1, 2] [6, 7] [3, 4] [8, 9] [5] [10] Applying `window` to a `Dataset` of dictionaries gives a dictionary of `Datasets`: >>> dataset = tf.data.Dataset.from_tensor_slices({'a': [1, 2, 3], ... 'b': [4, 5, 6], ... 'c': [7, 8, 9]}) >>> dataset = dataset.window(2) >>> def to_numpy(ds): ... return list(ds.as_numpy_iterator()) >>> >>> for windows in dataset: ... print(tf.nest.map_structure(to_numpy, windows)) {'a': [1, 2], 'b': [4, 5], 'c': [7, 8]} {'a': [3], 'b': [6], 'c': [9]} #### Flatten a dataset of windows The `Dataset.flat_map` and `Dataset.interleave` methods can be used to flatten a dataset of windows into a single dataset. The argument to `flat_map` is a function that takes an element from the dataset and returns a `Dataset`. `flat_map` chains together the resulting datasets sequentially. For example, to turn each window into a dense tensor: >>> dataset = tf.data.Dataset.range(7).window(3, shift=1, ... drop_remainder=True) >>> batched = dataset.flat_map(lambda x:x.batch(3)) >>> for batch in batched: ... print(batch.numpy()) [0 1 2] [1 2 3] [2 3 4] [3 4 5] [4 5 6] Args: size: A `tf.int64` scalar `tf.Tensor`, representing the number of elements of the input dataset to combine into a window. Must be positive. shift: (Optional.) A `tf.int64` scalar `tf.Tensor`, representing the number of input elements by which the window moves in each iteration. Defaults to `size`. Must be positive. stride: (Optional.) A `tf.int64` scalar `tf.Tensor`, representing the stride of the input elements in the sliding window. Must be positive. The default value of 1 means "retain every input element". drop_remainder: (Optional.) A `tf.bool` scalar `tf.Tensor`, representing whether the last windows should be dropped if their size is smaller than `size`. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. N)r=) WindowDataset)rVsizeshiftstrider,r=r>r>r?window szDatasetV2.windowc Cs tdt|}WdQRXt|}d}x~|rtj|d||jfdd}|j}t dd|}xDt t |t |D]*\} } t | | s~td |d |jd q~W|j} t d d|} xBt t | t | D](\} }| |krtd | d |jd qW|j}t dd|}t |}t |}ddt ||D}d}xHt ||D]:\}}|jdk rT|jdks||krTd}PqTW|r2t| t |||}q2W|j}|t|}t}|rt||_t|tj|j t!|||j"|t#|t$||%dS)aReduces the input dataset to a single element. The transformation calls `reduce_func` successively on every element of the input dataset until the dataset is exhausted, aggregating information in its internal state. The `initial_state` argument is used for the initial state and the final state is returned as the result. >>> tf.data.Dataset.range(5).reduce(np.int64(0), lambda x, _: x + 1).numpy() 5 >>> tf.data.Dataset.range(5).reduce(np.int64(0), lambda x, y: x + y).numpy() 10 Args: initial_state: An element representing the initial state of the transformation. reduce_func: A function that maps `(old_state, input_element)` to `new_state`. It must take two arguments and return a new element The structure of `new_state` must match the structure of `initial_state`. name: (Optional.) A name for the tf.data operation. Returns: A dataset element corresponding to the final state of the transformation. initial_stateNTzreduce()F)input_structurercSs|S)N)_to_legacy_output_classes)rr>r>r?r rz"DatasetV2.reduce..zMThe element classes for the new state must match the initial state. Expected z but got rIcSs|S)N)_to_legacy_output_types)rr>r>r?r rzKThe element types for the new state must match the initial state. Expected cSs|S)N)_to_legacy_output_shapes)rr>r>r?r rcSsg|]\}}||qSr>)most_specific_compatible_shape)rdoriginalnewr>r>r?rh sz$DatasetV2.reduce..)frrr)&rr7r rrrStructuredFunctionWrapperroutput_classesr rrrr>rSrrndimsas_listconvert_legacy_structurerrrrKrrrr@r=from_compatible_tensor_listrZreduce_datasetrZrcaptured_inputsrrrn)rVr reduce_funcr=Zstate_structure need_to_rerun wrapped_funcrZ state_classesnew_state_classZ state_classrZ state_typesnew_state_typeZ state_typerZ state_shapesflat_state_shapesflat_new_state_shapesweakened_state_shapesoriginal_shapeweakened_shaperrr>r>r?reduce s            zDatasetV2.reducecCs>t}|rt||_t|jtj|j fd| i|j S)aReturns the single element of the `dataset`. The function enables you to use a `tf.data.Dataset` in a stateless "tensor-in tensor-out" expression, without creating an iterator. This facilitates the ease of data transformation on tensors using the optimized `tf.data.Dataset` abstraction on top of them. For example, lets consider a `preprocessing_fn` which would take as an input the raw features and returns the processed feature along with it's label. ```python def preprocessing_fn(raw_feature): # ... the raw_feature is preprocessed as per the use-case return feature raw_features = ... # input batch of BATCH_SIZE elements. dataset = (tf.data.Dataset.from_tensor_slices(raw_features) .map(preprocessing_fn, num_parallel_calls=BATCH_SIZE) .batch(BATCH_SIZE)) processed_features = dataset.get_single_element() ``` In the above example, the `raw_features` tensor of length=BATCH_SIZE was converted to a `tf.data.Dataset`. Next, each of the `raw_feature` was mapped using the `preprocessing_fn` and the processed features were grouped into a single batch. The final `dataset` contains only one element which is a batch of all the processed features. NOTE: The `dataset` should contain only one element. Now, instead of creating an iterator for the `dataset` and retrieving the batch of features, the `tf.data.get_single_element()` function is used to skip the iterator creation process and directly output the batch of features. This can be particularly useful when your tensor transformations are expressed as `tf.data.Dataset` operations, and you want to use those transformations while serving your model. #### Keras ```python model = ... # A pre-built or custom model class PreprocessingModel(tf.keras.Model): def __init__(self, model): super().__init__(self) self.model = model @tf.function(input_signature=[...]) def serving_fn(self, data): ds = tf.data.Dataset.from_tensor_slices(data) ds = ds.map(preprocessing_fn, num_parallel_calls=BATCH_SIZE) ds = ds.batch(batch_size=BATCH_SIZE) return tf.argmax(self.model(ds.get_single_element()), axis=-1) preprocessing_model = PreprocessingModel(model) your_exported_model_dir = ... # save the model to this path. tf.saved_model.save(preprocessing_model, your_exported_model_dir, signatures={'serving_default': preprocessing_model.serving_fn} ) ``` #### Estimator In the case of estimators, you need to generally define a `serving_input_fn` which would require the features to be processed by the model while inferencing. ```python def serving_input_fn(): raw_feature_spec = ... # Spec for the raw_features input_fn = tf.estimator.export.build_parsing_serving_input_receiver_fn( raw_feature_spec, default_batch_size=None) ) serving_input_receiver = input_fn() raw_features = serving_input_receiver.features def preprocessing_fn(raw_feature): # ... the raw_feature is preprocessed as per the use-case return feature dataset = (tf.data.Dataset.from_tensor_slices(raw_features) .map(preprocessing_fn, num_parallel_calls=BATCH_SIZE) .batch(BATCH_SIZE)) processed_features = dataset.get_single_element() # Please note that the value of `BATCH_SIZE` should be equal to # the size of the leading dimension of `raw_features`. This ensures # that `dataset` has only element, which is a pre-requisite for # using `dataset.get_single_element()`. return tf.estimator.export.ServingInputReceiver( processed_features, serving_input_receiver.receiver_tensors) estimator = ... # A pre-built or custom estimator estimator.export_saved_model(your_exported_model_dir, serving_input_fn) ``` Args: name: (Optional.) A name for the tf.data operation. Returns: A nested structure of `tf.Tensor` objects, corresponding to the single element of `dataset`. Raises: InvalidArgumentError: (at runtime) if `dataset` does not contain exactly one element. r) rrr@r=r rrrZdataset_to_single_elementrZrnr)rVr=rr>r>r?get_single_element su zDatasetV2.get_single_elementcCst|}t||dS)aSplits elements of a dataset into multiple elements. For example, if elements of the dataset are shaped `[B, a0, a1, ...]`, where `B` may vary for each input element, then for each element in the dataset, the unbatched dataset will contain `B` consecutive elements of shape `[a0, a1, ...]`. >>> elements = [ [1, 2, 3], [1, 2], [1, 2, 3, 4] ] >>> dataset = tf.data.Dataset.from_generator(lambda: elements, tf.int64) >>> dataset = dataset.unbatch() >>> list(dataset.as_numpy_iterator()) [1, 2, 3, 1, 2, 1, 2, 3, 4] Note: `unbatch` requires a data copy to slice up the batched tensor into smaller, unbatched tensors. When optimizing performance, try to avoid unnecessary usage of `unbatch`. Args: name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. )r=)normalize_to_dense_UnbatchDataset)rVr=normalized_datasetr>r>r?unbatch szDatasetV2.unbatchcCst|||dS)aReturns a new `tf.data.Dataset` with the given options set. The options are "global" in the sense they apply to the entire dataset. If options are set multiple times, they are merged as long as different options do not use different non-default values. >>> ds = tf.data.Dataset.range(5) >>> ds = ds.interleave(lambda x: tf.data.Dataset.range(5), ... cycle_length=3, ... num_parallel_calls=3) >>> options = tf.data.Options() >>> # This will make the interleave order non-deterministic. >>> options.deterministic = False >>> ds = ds.with_options(options) Args: options: A `tf.data.Options` that identifies the options the use. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. Raises: ValueError: when an option is set more than once to a non-default value )r=)r)rVrr=r>r>r? with_options szDatasetV2.with_optionscCs t|jS)aReturns the cardinality of the dataset, if known. `cardinality` may return `tf.data.INFINITE_CARDINALITY` if the dataset contains an infinite number of elements or `tf.data.UNKNOWN_CARDINALITY` if the analysis fails to determine the number of elements in the dataset (e.g. when the dataset source is a file). >>> dataset = tf.data.Dataset.range(42) >>> print(dataset.cardinality().numpy()) 42 >>> dataset = dataset.repeat() >>> cardinality = dataset.cardinality() >>> print((cardinality == tf.data.INFINITE_CARDINALITY).numpy()) True >>> dataset = dataset.filter(lambda x: True) >>> cardinality = dataset.cardinality() >>> print((cardinality == tf.data.UNKNOWN_CARDINALITY).numpy()) True Returns: A scalar `tf.int64` `Tensor` representing the cardinality of the dataset. If the cardinality is infinite or unknown, `cardinality` returns the named constants `tf.data.INFINITE_CARDINALITY` and `tf.data.UNKNOWN_CARDINALITY` respectively. )rZdataset_cardinalityrZ)rVr>r>r?r szDatasetV2.cardinalitycsVdk r |sdk s |s tddk r8fdd}|}|dk sDtt|||||dS)aWGroups windows of elements by key and reduces them. This transformation maps each consecutive element in a dataset to a key using `key_func` and groups the elements by key. It then applies `reduce_func` to at most `window_size_func(key)` elements matching the same key. All except the final window for each key will contain `window_size_func(key)` elements; the final window may be smaller. You may provide either a constant `window_size` or a window size determined by the key through `window_size_func`. >>> dataset = tf.data.Dataset.range(10) >>> window_size = 5 >>> key_func = lambda x: x%2 >>> reduce_func = lambda key, dataset: dataset.batch(window_size) >>> dataset = dataset.group_by_window( ... key_func=key_func, ... reduce_func=reduce_func, ... window_size=window_size) >>> for elem in dataset.as_numpy_iterator(): ... print(elem) [0 2 4 6 8] [1 3 5 7 9] Args: key_func: A function mapping a nested structure of tensors (having shapes and types defined by `self.output_shapes` and `self.output_types`) to a scalar `tf.int64` tensor. reduce_func: A function mapping a key and a dataset of up to `window_size` consecutive elements matching that key to another dataset. window_size: A `tf.int64` scalar `tf.Tensor`, representing the number of consecutive elements matching the same key to combine in a single batch, which will be passed to `reduce_func`. Mutually exclusive with `window_size_func`. window_size_func: A function mapping a key to a `tf.int64` scalar `tf.Tensor`, representing the number of consecutive elements matching the same key to combine in a single batch, which will be passed to `reduce_func`. Mutually exclusive with `window_size`. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. Raises: ValueError: if neither or both of {`window_size`, `window_size_func`} are passed. NzWEither the `window_size` argument or the `window_size_func` argument must be specified.cstjtjdS)N)r)rr8rr)Z unused_key) window_sizer>r?constant_window_func sz7DatasetV2.group_by_window..constant_window_func)r=)r;r_GroupByWindowDataset)rVkey_funcrrwindow_size_funcr=rr>)rr?group_by_window s5    zDatasetV2.group_by_windowc sttdkr2tdtdtdtjtjdfdd} fdd  dd d  f d d} |j| | dS)a A transformation that buckets elements in a `Dataset` by length. Elements of the `Dataset` are grouped together by length and then are padded and batched. This is useful for sequence tasks in which the elements have variable length. Grouping together elements that have similar lengths reduces the total fraction of padding in a batch which increases training step efficiency. Below is an example to bucketize the input data to the 3 buckets "[0, 3), [3, 5), [5, inf)" based on sequence length, with batch size 2. >>> elements = [ ... [0], [1, 2, 3, 4], [5, 6, 7], ... [7, 8, 9, 10, 11], [13, 14, 15, 16, 19, 20], [21, 22]] >>> dataset = tf.data.Dataset.from_generator( ... lambda: elements, tf.int64, output_shapes=[None]) >>> dataset = dataset.bucket_by_sequence_length( ... element_length_func=lambda elem: tf.shape(elem)[0], ... bucket_boundaries=[3, 5], ... bucket_batch_sizes=[2, 2, 2]) >>> for elem in dataset.as_numpy_iterator(): ... print(elem) [[1 2 3 4] [5 6 7 0]] [[ 7 8 9 10 11 0] [13 14 15 16 19 20]] [[ 0 0] [21 22]] Args: element_length_func: function from element in `Dataset` to `tf.int32`, determines the length of the element, which will determine the bucket it goes into. bucket_boundaries: `list`, upper length boundaries of the buckets. bucket_batch_sizes: `list`, batch size per bucket. Length should be `len(bucket_boundaries) + 1`. padded_shapes: Nested structure of `tf.TensorShape` to pass to `tf.data.Dataset.padded_batch`. If not provided, will use `dataset.output_shapes`, which will result in variable length dimensions being padded out to the maximum length in each batch. padding_values: Values to pad with, passed to `tf.data.Dataset.padded_batch`. Defaults to padding with 0. pad_to_bucket_boundary: bool, if `False`, will pad dimensions with unknown size to maximum length in batch. If `True`, will pad dimensions with unknown size to bucket boundary minus 1 (i.e., the maximum length in each bucket), and caller must ensure that the source `Dataset` does not contain any elements with length longer than `max(bucket_boundaries)`. no_padding: `bool`, indicates whether to pad the batch features (features need to be either of type `tf.sparse.SparseTensor` or of same shape). drop_remainder: (Optional.) A `tf.bool` scalar `tf.Tensor`, representing whether the last batch should be dropped in the case it has fewer than `batch_size` elements; the default behavior is not to drop the smaller batch. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. Raises: ValueError: if `len(bucket_batch_sizes) != len(bucket_boundaries) + 1`. rz_`len(bucket_batch_sizes)` must equal `len(bucket_boundaries) + 1` but `len(bucket_batch_sizes)=z` and `len(bucket_boundaries)=z`.)rcsh|}t}ttjjg|}|ttjjg}tt||t ||}t t |}|S)z6Return int64 id of the length bucket for this element.) r rrFint32minrGr# logical_andZ less_equalless reduce_minrwhere)rZ seq_length boundariesZ buckets_minZ buckets_maxZ conditions_c bucket_id)bucket_boundarieselement_length_funcr>r?element_to_bucket_idi s zADatasetV2.bucket_by_sequence_length..element_to_bucket_idcs |}|S)Nr>)rr) batch_sizesr>r?window_size_fnw sz;DatasetV2.bucket_by_sequence_length..window_size_fnNcsJg}x8t|D]*}t|}fdd|D}||qWt||S)Ncs"g|]}t|dkrn|qS)N)rZdimension_value)rdd) none_fillerr>r?rh szSDatasetV2.bucket_by_sequence_length..make_padded_shapes..)r rrrrr)shapesrZpaddedrr>)rr?make_padded_shapes| s  z?DatasetV2.bucket_by_sequence_length..make_padded_shapesc s |}r|j|dSd}rd}tj|tjtdtjd|d}t |g&tjtjd}||}|d}WdQRXt |}p||d} |j || dS)zBatch elements in dataset.)r,r=NzUWhen pad_to_bucket_boundary=True, elements must have length < max(bucket_boundaries).r)r)r3)r) rdrZ assert_lessrconstantrrrrr<reri) rZgrouped_datasetr+rerr_msgcheckrZbucket_boundary input_shapesr) bucket_batch_sizesrr,rr= no_paddingpad_to_bucket_boundaryrgrhrr>r? batching_fn s4  z8DatasetV2.bucket_by_sequence_length..batching_fn)rrrr=)N)rr;rrrrr) rVrrrrgrhrrr,r=rrr>) rrrr,rrr=rrrgrhrr?bucket_by_sequence_length sI  z#DatasetV2.bucket_by_sequence_lengthcCs t||dS)aCreates a `Dataset` of pseudorandom values. The dataset generates a sequence of uniformly distributed integer values. >>> ds1 = tf.data.Dataset.random(seed=4).take(10) >>> ds2 = tf.data.Dataset.random(seed=4).take(10) >>> print(list(ds1.as_numpy_iterator())==list(ds2.as_numpy_iterator())) True Args: seed: (Optional) If specified, the dataset produces a deterministic sequence of values. name: (Optional.) A name for the tf.data operation. Returns: Dataset: A `Dataset`. )r6r=) RandomDataset)r6r=r>r>r?random szDatasetV2.randomAUTOc Cs`d}|}|dkr.|j|d}dd}dd}n|}t||||||d} |dk r\| j||d} | S)a API to persist the output of the input dataset. The snapshot API allows users to transparently persist the output of their preprocessing pipeline to disk, and materialize the pre-processed data on a different training run. This API enables repeated preprocessing steps to be consolidated, and allows re-use of already processed data, trading off disk storage and network bandwidth for freeing up more valuable CPU resources and accelerator compute time. https://github.com/tensorflow/community/blob/master/rfcs/20200107-tf-data-snapshot.md has detailed design documentation of this feature. Users can specify various options to control the behavior of snapshot, including how snapshots are read from and written to by passing in user-defined functions to the `reader_func` and `shard_func` parameters. `shard_func` is a user specified function that maps input elements to snapshot shards. Users may want to specify this function to control how snapshot files should be written to disk. Below is an example of how a potential `shard_func` could be written. ```python dataset = ... dataset = dataset.enumerate() dataset = dataset.snapshot("/path/to/snapshot/dir", shard_func=lambda x, y: x % NUM_SHARDS, ...) dataset = dataset.map(lambda x, y: y) ``` `reader_func` is a user specified function that accepts a single argument: (1) a Dataset of Datasets, each representing a "split" of elements of the original dataset. The cardinality of the input dataset matches the number of the shards specified in the `shard_func` (see above). The function should return a Dataset of elements of the original dataset. Users may want specify this function to control how snapshot files should be read from disk, including the amount of shuffling and parallelism. Here is an example of a standard reader function a user can define. This function enables both dataset shuffling and parallel reading of datasets: ```python def user_reader_func(datasets): # shuffle the datasets splits datasets = datasets.shuffle(NUM_CORES) # read datasets in parallel and interleave their elements return datasets.interleave(lambda x: x, num_parallel_calls=AUTOTUNE) dataset = dataset.snapshot("/path/to/snapshot/dir", reader_func=user_reader_func) ``` By default, snapshot parallelizes reads by the number of cores available on the system, but will not attempt to shuffle the data. Args: path: Required. A directory to use for storing / loading the snapshot to / from. compression: Optional. The type of compression to apply to the snapshot written to disk. Supported options are `GZIP`, `SNAPPY`, `AUTO` or None. Defaults to `AUTO`, which attempts to pick an appropriate compression algorithm for the dataset. reader_func: Optional. A function to control how to read data from snapshot shards. shard_func: Optional. A function to control how to shard data when writing a snapshot. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. N)r=cSs |tS)N)multiprocessing cpu_count)rVr[r>r>r?r rz$DatasetV2.snapshot..cSs|S)Nr>)r[elemr>r>r?r r)rXrZr[r^r\r=)rq_SnapshotDatasetrn) rVrZr[r^r\r=Z project_funcrXZlocal_shard_funcrr>r>r?snapshot s"R  zDatasetV2.snapshotcCst||||dS)aA transformation that scans a function across an input dataset. This transformation is a stateful relative of `tf.data.Dataset.map`. In addition to mapping `scan_func` across the elements of the input dataset, `scan()` accumulates one or more state tensors, whose initial values are `initial_state`. >>> dataset = tf.data.Dataset.range(10) >>> initial_state = tf.constant(0, dtype=tf.int64) >>> scan_func = lambda state, i: (state + i, state + i) >>> dataset = dataset.scan(initial_state=initial_state, scan_func=scan_func) >>> list(dataset.as_numpy_iterator()) [0, 1, 3, 6, 10, 15, 21, 28, 36, 45] Args: initial_state: A nested structure of tensors, representing the initial state of the accumulator. scan_func: A function that maps `(old_state, input_element)` to `(new_state, output_element)`. It must take two arguments and return a pair of nested structures of tensors. The `new_state` must match the structure of `initial_state`. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. )r scan_funcr=) _ScanDataset)rVrrr=r>r>r?scan+ szDatasetV2.scancCst|||dS)aLA transformation that stops dataset iteration based on a `predicate`. >>> dataset = tf.data.Dataset.range(10) >>> dataset = dataset.take_while(lambda x: x < 5) >>> list(dataset.as_numpy_iterator()) [0, 1, 2, 3, 4] Args: predicate: A function that maps a nested structure of tensors (having shapes and types defined by `self.output_shapes` and `self.output_types`) to a scalar `tf.bool` tensor. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. )r=)_TakeWhileDataset)rVryr=r>r>r? take_whileJ szDatasetV2.take_whilecCs t||dS)aA transformation that discards duplicate elements of a `Dataset`. Use this transformation to produce a dataset that contains one instance of each unique element in the input. For example: >>> dataset = tf.data.Dataset.from_tensor_slices([1, 37, 2, 37, 2, 1]) >>> dataset = dataset.unique() >>> sorted(list(dataset.as_numpy_iterator())) [1, 2, 37] Note: This transformation only supports datasets which fit into memory and have elements of either `tf.int32`, `tf.int64` or `tf.string` type. Args: name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. )r=)_UniqueDataset)rVr=r>r>r?unique^ szDatasetV2.uniquecsvtj|ddttj|dk rtj|dd}t|tj}t|\}}tj||dj |d} tj||dj |d} tj||dj |d} nRt |j |d|d} | j fdd|d} | j dd|d} | j dd|d} t || | |} | j d |d} |dk rt|nd}fd d }|d kr>|j ||dS|d krL| Stj| || g| dd|ddSdS)aCResamples elements to reach a target distribution. Note: This implementation can reject **or repeat** elements in order to reach the `target_dist`. So, in some cases, the output `Dataset` may be larger than the input `Dataset`. >>> initial_dist = [0.6, 0.4] >>> n = 1000 >>> elems = np.random.choice(len(initial_dist), size=n, p=initial_dist) >>> dataset = tf.data.Dataset.from_tensor_slices(elems) >>> zero, one = np.bincount(list(dataset.as_numpy_iterator())) / n Following from `initial_dist`, `zero` is ~0.6 and `one` is ~0.4. >>> target_dist = [0.5, 0.5] >>> dataset = dataset.rejection_resample( ... class_func=lambda x: x, ... target_dist=target_dist, ... initial_dist=initial_dist) >>> dataset = dataset.map(lambda class_func_result, data: data) >>> zero, one = np.bincount(list(dataset.as_numpy_iterator())) / n Following from `target_dist`, `zero` is ~0.5 and `one` is ~0.5. Args: class_func: A function mapping an element of the input dataset to a scalar `tf.int32` tensor. Values should be in `[0, num_classes)`. target_dist: A floating point type tensor, shaped `[num_classes]`. initial_dist: (Optional.) A floating point type tensor, shaped `[num_classes]`. If not provided, the true class distribution is estimated live in a streaming fashion. seed: (Optional.) Python integer seed for the resampler. name: (Optional.) A name for the tf.data operation. Returns: A new `Dataset` with the transformation applied as described above. target_dist)r=N initial_distcs t|S)N)'_calculate_acceptance_probs_with_mixing)initial) target_dist_tr>r?r sz.DatasetV2.rejection_resample..cSs|S)Nr>)Z accept_probr[r>r>r?r rcSs|S)Nr>)r[Z prob_originalr>r>r?r rcs,t|dkr||dfS||fSdS)Nrr)r)r) class_funcr>r?add_class_value s z5DatasetV2.rejection_resample..add_class_valuerrcSs|d|fgS)Ng?r>)Zprobr>r>r?r rT)weightsr6stop_on_empty_dataset)rr8r#castrfloat32rrGrrD_estimate_initial_dist_dsrn _filter_dsr/_get_prob_original_staticrsample_from_datasets)rVrrrr6r=initial_dist_tZacceptance_distZprob_of_originalinitial_dist_dsacceptance_dist_dsZprob_of_original_dsZacceptance_and_original_prob_ds filtered_dsZprob_original_staticrr>)rrr?rejection_resampleu sH.       zDatasetV2.rejection_resamplec sdd}|stdt|ts8|dkr:dgt|gnt|tjrl|jt|gstd|jdn.t|t|krtdt|d t|d t|tjs|||\}}tj|d d }|j t j t j fkrt d |j dttj|dd dt|dkr|dSfdd}tt|d|dd}n<|dd}dd}t|t|df} t| |dd}t|||S)aSamples elements at random from the datasets in `datasets`. Creates a dataset by interleaving elements of `datasets` with `weight[i]` probability of picking an element from dataset `i`. Sampling is done without replacement. For example, suppose we have 2 datasets: ```python dataset1 = tf.data.Dataset.range(0, 3) dataset2 = tf.data.Dataset.range(100, 103) ``` Suppose that we sample from these 2 datasets with the following weights: ```python sample_dataset = tf.data.Dataset.sample_from_datasets( [dataset1, dataset2], weights=[0.5, 0.5]) ``` One possible outcome of elements in sample_dataset is: ``` print(list(sample_dataset.as_numpy_iterator())) # [100, 0, 1, 101, 2, 102] ``` Args: datasets: A non-empty list of `tf.data.Dataset` objects with compatible structure. weights: (Optional.) A list or Tensor of `len(datasets)` floating-point values where `weights[i]` represents the probability to sample from `datasets[i]`, or a `tf.data.Dataset` object where each element is such a list. Defaults to a uniform distribution across `datasets`. seed: (Optional.) A `tf.int64` scalar `tf.Tensor`, representing the random seed that will be used to create the distribution. See `tf.random.set_seed` for behavior. stop_on_empty_dataset: If `True`, sampling stops if it encounters an empty dataset. If `False`, it continues sampling and skips any empty datasets. It is recommended to set it to `True`. Otherwise, the distribution of samples starts off as the user intends, but may change as input datasets become empty. This can be difficult to detect since the dataset starts off looking correct. Default to `False` for backward compatibility. Returns: A dataset that interleaves elements from `datasets` at random, according to `weights` if provided, otherwise with uniform probability. Raises: TypeError: If the `datasets` or `weights` arguments have the wrong type. ValueError: - If `datasets` is empty, or - If `weights` is specified and does not match the length of `datasets`. cSs6ddt||D}|r t|S|ddgdgfS)NcSs g|]\}}|dkr||fqS)rr>)rdrweightr>r>r?rhsz[DatasetV2.sample_from_datasets.._skip_datasets_with_zero_weight..rg?)rrQ)r"rZdatasets_and_weightsr>r>r?_skip_datasets_with_zero_weights zGDatasetV2.sample_from_datasets.._skip_datasets_with_zero_weightz3Invalid `datasets`. `datasets` should not be empty.Ng?z]Invalid `weights`. The shape of `weights` should be compatible with `[len(datasets)]` but is rIz]Invalid `weights`. `weights` should have the same length as `datasets` but got `len(weights)=z` vs. `len(datasets)=z`.r)r=zUInvalid `weights`. `weights` type must be either `tf.float32` or `tf.float64` but is logitsrrcstjtjd|dddgdS)Nr)r6r)r)rsqueezer!stateless_multinomial)r6)rr>r?select_dataset_constant_logitsAs zFDatasetV2.sample_from_datasets..select_dataset_constant_logitsF)use_inter_op_parallelismcWstj|ddS)Nr)r=)r#log)pr>r>r?rRrz0DatasetV2.sample_from_datasets..cSstjtj|d|dddgdS)Nr)r6r)r)rrr!r)rr6r>r>r?select_dataset_varying_logitsTs zEDatasetV2.sample_from_datasets..select_dataset_varying_logits)r;rArGrrZTensorrrr8rrrZfloat64rSrrr#rrkrrdrnrr_DirectedInterleaveDataset) r"rr6rrrselector_inputZ logits_dsrZlogits_and_seedsr>)rr?r sB:      zDatasetV2.sample_from_datasetsTcCsj|s tdt|ts*tdt|dt|jt gt j sTtd|jdt |d}t |||S)aCreates a dataset that deterministically chooses elements from `datasets`. For example, given the following datasets: ```python datasets = [tf.data.Dataset.from_tensors("foo").repeat(), tf.data.Dataset.from_tensors("bar").repeat(), tf.data.Dataset.from_tensors("baz").repeat()] # Define a dataset containing `[0, 1, 2, 0, 1, 2, 0, 1, 2]`. choice_dataset = tf.data.Dataset.range(3).repeat(3) result = tf.data.Dataset.choose_from_datasets(datasets, choice_dataset) ``` The elements of `result` will be: ``` "foo", "bar", "baz", "foo", "bar", "baz", "foo", "bar", "baz" ``` Args: datasets: A non-empty list of `tf.data.Dataset` objects with compatible structure. choice_dataset: A `tf.data.Dataset` of scalar `tf.int64` tensors between `0` and `len(datasets) - 1`. stop_on_empty_dataset: If `True`, selection stops if it encounters an empty dataset. If `False`, it skips empty datasets. It is recommended to set it to `True`. Otherwise, the selected elements start off as the user intends, but may change as input datasets become empty. This can be difficult to detect since the dataset starts off looking correct. Defaults to `True`. Returns: A new `Dataset` with the transformation applied as described above. Raises: TypeError: If `datasets` or `choice_dataset` has the wrong type. ValueError: If `datasets` is empty. z3Invalid `datasets`. `datasets` should not be empty.zPInvalid `choice_dataset`. `choice_dataset` should be a `tf.data.Dataset` but is rIzaInvalid `choice_dataset`. Elements of `choice_dataset` must be scalar `tf.int64` tensors but are rE)r;rArGrSrDr rrrrrrrHr)r"Zchoice_datasetrr>r>r?choose_from_datasetscs,  zDatasetV2.choose_from_datasets)N)N)NNNNN)N)N)FN)N)NNN)NN)rN)NNN)rLN)N)N)N)NNN)NNN)FNNN)NNFN)NNN)N)FN)NNNNN)N)NrFN)N)N)N)N)NNN)NNFFFN)NN)rNNN)N)N)N)NNN)NNF)T)]rrrrrYpropertyrZsetterr,deprecated_argsrMrWARNr`rtrwrx CHECKPOINTr{ruabcabstractmethodrPrrr classmethodrrrrr __nonzero__rabstractpropertyrrrrrrrrrr staticmethodrrrrr rr$rrr&r*r/r0rDrqr@rOrQrSrWrYr_rdrirnrrqrvrxr|rrrrrrrrrrrrrrrr __classcell__r>r>)rr?rGsX&  7  ;     & R,1 & / ' 4  L  ) D 5   G J D B  $ #  |   v    E    f    ]  rG) metaclasscsxeZdZdZfddZejddZe dddd Z d d Z e dd d[d dZ d\ddZ ee ddddZee ddddZee ddddZeddZeeejd]ddZeeejd^ddZee dd d!d"Zeeejedd#d$d%d_d&d'Zeeejd(d)Zeeejd`d*d+Zeejdafd,d- Zeejdbfd.d/ Zeeej dcd0d1Z eej!ddfd2d3 Z!eej"defd4d5 Z"eej#dffd7d8 Z#eej$dgfd9d: Z$eej%dhfd;d< Z%eej&difd=d> Z&eej'djfd@dA Z'eej(dkfdBdC Z(eej)dldDdEZ)e ddFdmdGdHZ*eej+dnfdIdJ Z+eej,dofdKdL Z,eej-dpfdMdN Z-e ddOdPdQZ.eej/fdRdSZ/eej0dqfdUdV Z0eej1drfdWdX Z1eej2dsfdYdZ Z2Z3S)trQzRepresents a potentially large set of elements. A `Dataset` can be used to represent an input pipeline as a collection of elements and a "logical plan" of transformations that act on those elements. c sfy |}WnDtk rP}z&dt|kr2tdtd|Wdd}~XYnXtt||dS)N_as_variant_tensorzoPlease use `_variant_tensor` instead of `_as_variant_tensor()` to obtain the variant associated with a dataset.aC{}: A likely cause of this error is that the super call for this dataset is not the last line of the `__init__` method. The base class invokes the `_as_variant_tensor()` method in its constructor and if that method uses attributes defined in the `__init__` method, those attributes need to be defined before the super call.)rAttributeErrorrcformatrzrQrY)rVrWr)rr>r?rYs  zDatasetV1.__init__cCstt|ddS)zCreates a scalar `tf.Tensor` of `tf.variant` representing this dataset. Returns: A scalar `tf.Tensor` of `tf.variant` type, which represents this dataset. z.as_variant_tensor()N)rrD)rVr>r>r?rszDatasetV1._as_variant_tensorNa This is a deprecated API that should only be used in TF 1 graph mode and legacy TF 2 graph mode available through `tf.compat.v1`. In all other situations -- namely, eager mode and inside `tf.function` -- you can consume dataset elements using `for elem in dataset: ...` or by explicitly creating iterator via `iterator = iter(dataset)` and fetching its elements via `values = next(iterator)`. Furthermore, this API is not available in TF 2. During the transition from TF 1 to TF 2 you can use `tf.compat.v1.data.make_one_shot_iterator(dataset)` to create a TF 1 graph mode style iterator for a dataset created through TF 2 APIs. Note that this should be a transient state of your code base as there are in general no guarantees about the interoperability of TF 1 and TF 2 code.cCs|S)akCreates an iterator for elements of this dataset. Note: The returned iterator will be initialized automatically. A "one-shot" iterator does not currently support re-initialization. For that see `make_initializable_iterator`. Example: ```python # Building graph ... dataset = ... next_value = dataset.make_one_shot_iterator().get_next() # ... from within a session ... try: while True: value = sess.run(next_value) ... except tf.errors.OutOfRangeError: pass ``` Returns: An `tf.data.Iterator` for elements of this dataset. )_make_one_shot_iterator)rVr>r>r?make_one_shot_iterators'z DatasetV1.make_one_shot_iteratorc str&tj tSQRXtt }t d\t j d|dfdd}y|tWnBtk r}z$dt|krtd|dnWdd}~XYnXtj2ttjfd|ijdtttSQRXdS)NT)Zcapture_by_valueallowlisted_stateful_opscs8dk r*dk sttdd}|jS)zFactory function for a dataset.Ni9l)rcore_random_seedZset_random_seedrrZ)r)graph_level_seed op_level_seedrVr>r? _make_datasets  z8DatasetV1._make_one_shot_iterator.._make_datasetzCannot capture a stateful nodea{}: A likely cause of this error is that the dataset for which you are calling `make_one_shot_iterator()` captures a stateful object, such as a `tf.Variable` or `tf.lookup.StaticHashTable`, which is not supported. Use `make_initializable_iterator()` instead.Zdataset_factory)r rrrrZrr_ensure_same_dataset_graphr Zobtain_capture_by_value_opsrget_seedrZDefunrrKr;rcrIteratorrZone_shot_iteratorrget_legacy_output_typesreget_legacy_output_classes)rVrr errr>)r r rVr?rs.    z!DatasetV1._make_one_shot_iteratoraThis is a deprecated API that should only be used in TF 1 graph mode and legacy TF 2 graph mode available through `tf.compat.v1`. In all other situations -- namely, eager mode and inside `tf.function` -- you can consume dataset elements using `for elem in dataset: ...` or by explicitly creating iterator via `iterator = iter(dataset)` and fetching its elements via `values = next(iterator)`. Furthermore, this API is not available in TF 2. During the transition from TF 1 to TF 2 you can use `tf.compat.v1.data.make_initializable_iterator(dataset)` to create a TF 1 graph mode style iterator for a dataset created through TF 2 APIs. Note that this should be a transient state of your code base as there are in general no guarantees about the interoperability of TF 1 and TF 2 code.cCs ||S)aCreates an iterator for elements of this dataset. Note: The returned iterator will be in an uninitialized state, and you must run the `iterator.initializer` operation before using it: ```python # Building graph ... dataset = ... iterator = dataset.make_initializable_iterator() next_value = iterator.get_next() # This is a Tensor. # ... from within a session ... sess.run(iterator.initializer) try: while True: value = sess.run(next_value) ... except tf.errors.OutOfRangeError: pass ``` Args: shared_name: (Optional.) If non-empty, the returned iterator will be shared under the given name across multiple sessions that share the same devices (e.g. when using a remote server). Returns: A `tf.data.Iterator` for elements of this dataset. Raises: RuntimeError: If eager execution is enabled. )_make_initializable_iterator)rV shared_namer>r>r?make_initializable_iterator!s/z%DatasetV1.make_initializable_iteratorc Cstrtdt||}|dkr,d}t|jFtj fd|d|j }t |j|}t ||t|t|t|SQRXdS)Nzc`make_initializable_iterator()` is not supported in eager mode. Use Python-style iteration instead.rL) containerr)r rrr rrrrZrZ iterator_v2rZ make_iteratorrrrrer)rVrriterator_resourceZ initializerr>r>r?rRs z&DatasetV1._make_initializable_iteratorz4Use `tf.compat.v1.data.get_output_classes(dataset)`.cCstdd|jS)zReturns the class of each component of an element of this dataset. Returns: A (nested) structure of Python `type` objects corresponding to each component of an element of this dataset. cSs|S)N)r)rr>r>r?rtrz*DatasetV1.output_classes..)r rr)rVr>r>r?ris zDatasetV1.output_classesz3Use `tf.compat.v1.data.get_output_shapes(dataset)`.cCstdd|jS)zReturns the shape of each component of an element of this dataset. Returns: A (nested) structure of `tf.TensorShape` objects corresponding to each component of an element of this dataset. cSs|S)N)r)rr>r>r?rrz)DatasetV1.output_shapes..)r rr)rVr>r>r?rws zDatasetV1.output_shapesz2Use `tf.compat.v1.data.get_output_types(dataset)`.cCstdd|jS)zReturns the type of each component of an element of this dataset. Returns: A (nested) structure of `tf.DType` objects corresponding to each component of an element of this dataset. cSs|S)N)r)rr>r>r?rrz(DatasetV1.output_types..)r rr)rVr>r>r?rs zDatasetV1.output_typescCst|j|j|jS)N)r rrrr)rVr>r>r?rszDatasetV1.element_speccCsttj||dS)N)r=)rrGr)rr=r>r>r?rszDatasetV1.from_tensorscCsttj||dS)N)r=)rrGr)rr=r>r>r?rszDatasetV1.from_tensor_slicesz+Use `tf.data.Dataset.from_tensor_slices()`.cCs tt|S)zSplits each rank-N `tf.sparse.SparseTensor` in this dataset row-wise. Args: sparse_tensor: A `tf.sparse.SparseTensor`. Returns: Dataset: A `Dataset` of rank-(N-1) sparse tensors. )rSparseTensorSliceDataset)rr>r>r?from_sparse_tensor_slicess z#DatasetV1.from_sparse_tensor_sliceszUse output_signature insteadrrc Cs.tttj||||||dSQRXdS)N)r=)r,ZsilencerrGr)rrrrr r=r>r>r?rs zDatasetV1.from_generatorcOsttj||S)N)rrGr )rr~r>r>r?r szDatasetV1.rangecCsttj||dS)N)r=)rrGr)r"r=r>r>r?rsz DatasetV1.zipcsttt|j||dS)N)r=)rrzrQr$)rVrr=)rr>r?r$szDatasetV1.concatenatecsttt|j||dS)N)r=)rrzrQr/)rVr.r=)rr>r?r/szDatasetV1.prefetchcCsttj||||dS)N)r=)rrGr0)r1r@r6r=r>r>r?r0szDatasetV1.list_filescsttt|j||dS)N)r=)rrzrQrD)rVrCr=)rr>r?rDszDatasetV1.repeatcsttt|j||||dS)N)r=)rrzrQr@)rVr.r6rKr=)rr>r?r@s zDatasetV1.shufflerLcsttt|j||dS)N)r=)rrzrQrO)rVrNr=)rr>r?rOszDatasetV1.cachecsttt|j||dS)N)r=)rrzrQrQ)rVrCr=)rr>r?rQszDatasetV1.takecsttt|j||dS)N)r=)rrzrQrS)rVrCr=)rr>r?rSszDatasetV1.skipcsttt|j|||dS)N)r=)rrzrQrW)rVrUrVr=)rr>r?rWszDatasetV1.shardFcsttt|j|||||dS)N)r=)rrzrQrd)rVr+r,rbrcr=)rr>r?rds zDatasetV1.batchcsttt|j|||||dS)N)r=)rrzrQri)rVr+rgrhr,r=)rr>r?ris zDatasetV1.padded_batchcCs8|dks trtt||ddStt||||ddSdS)NF)rj)rrrkrl)rVrmrbrcr=r>r>r?rns z DatasetV1.mapzUse `tf.data.Dataset.map()c CsJ|dkr.|dk rtdtt||dddStt||||dddSdS)aMaps `map_func` across the elements of this dataset. Note: This is an escape hatch for existing uses of `map` that do not work with V2 functions. New uses are strongly discouraged and existing uses should migrate to `map` as this method will be removed in V2. Args: map_func: A function mapping a (nested) structure of tensors (having shapes and types defined by `self.output_shapes` and `self.output_types`) to another (nested) structure of tensors. num_parallel_calls: (Optional.) A `tf.int32` scalar `tf.Tensor`, representing the number elements to process asynchronously in parallel. If not specified, elements will be processed sequentially. If the value `tf.data.AUTOTUNE` is used, then the number of parallel calls is set dynamically based on available CPU. deterministic: (Optional.) When `num_parallel_calls` is specified, this boolean controls the order in which the transformation produces elements. If set to `False`, the transformation is allowed to yield elements out of order to trade determinism for performance. If not specified, the `tf.data.Options.deterministic` option (`True` by default) controls the behavior. Returns: Dataset: A `Dataset`. NzaThe `deterministic` argument has no effect unless the `num_parallel_calls` argument is specified.FT)rjuse_legacy_function)rrrrkrl)rVrmrbrcr>r>r?map_with_legacy_function0s"  z"DatasetV1.map_with_legacy_functioncsttt|j||dS)N)r=)rrzrQr)rVrmr=)rr>r?rbszDatasetV1.flat_mapc s ttt|j||||||dS)N)r=)rrzrQrv)rVrmrtrurbrcr=)rr>r?rvgs zDatasetV1.interleavecsttt|j||dS)N)r=)rrzrQrx)rVryr=)rr>r?rxxszDatasetV1.filterzUse `tf.data.Dataset.filter()cCsddlm}|j||ddS)abFilters this dataset according to `predicate`. Note: This is an escape hatch for existing uses of `filter` that do not work with V2 functions. New uses are strongly discouraged and existing uses should migrate to `filter` as this method will be removed in V2. Args: predicate: A function mapping a (nested) structure of tensors (having shapes and types defined by `self.output_shapes` and `self.output_types`) to a scalar `tf.bool` tensor. Returns: Dataset: The `Dataset` containing the elements of this dataset for which `predicate` is `True`. r)rwT)r)rrwZ FilterDataset)rVryrwr>r>r?filter_with_legacy_function|s z%DatasetV1.filter_with_legacy_functioncsttt||S)N)rrzrQr|)rVr{)rr>r?r|szDatasetV1.applyrcsttt|j|||||dS)N)r=)rrzrQr)rVr~rrr,r=)rr>r?rszDatasetV1.windowcsttt|j|dS)N)r=)rrzrQr)rVr=)rr>r?rszDatasetV1.unbatchcsttt|j||dS)N)r=)rrzrQr)rVrr=)rr>r?rszDatasetV1.with_options)N)N)N)N)NNNNN)N)N)N)NNN)NN)NNN)rLN)N)N)N)FNNN)NNFN)NNN)NN)N)NNNNN)N)NrFN)N)N)4rrrrrYrrrr, deprecatedrrrrrrrrrr functoolswrapsrGrrrrrr rr$r/r0rDr@rOrQrSrWrdrirnrrrvrxrr|rrrrr>r>)rr?rQs  (3 #                        .      rQcsTeZdZdZfddZddZddZdd Zd d Ze d d Z ddZ Z S)rzCWraps a V2 `Dataset` object in the `tf.compat.v1.data.Dataset` API.cs||_tt|dS)N)rHrzrrY)rVr)rr>r?rYszDatasetV1Adapter.__init__cCs|jjS)N)rHrZ)rVr>r>r?rsz#DatasetV1Adapter._as_variant_tensorcCs |jS)N)rHrP)rVr>r>r?rPszDatasetV1Adapter._inputscCs |jS)N)rHr)rVr>r>r?rszDatasetV1Adapter._functionscCs |jS)N)rHr)rVr>r>r?rszDatasetV1Adapter.optionscCs|jjS)N)rHr)rVr>r>r?rszDatasetV1Adapter.element_speccCs t|jS)N)rrH)rVr>r>r?rszDatasetV1Adapter.__iter__) rrrrrYrrPrrrrrrr>r>)rr?rs  rcCst}t}||g}xn|s|}|||j}||krft d|d|d|j dx"| D]}||krp||qpWq WdS)zHWalks the dataset graph to ensure all datasets come from the same graph.z The graph z- of the iterator is different from the graph z the dataset: z was created in. If you are using the Estimator API, make sure that no part of the dataset returned by the `input_fn` function is defined outside the `input_fn` function. Otherwise, make sure that the dataset is created in the same graph as the iterator.N) rrKqueueQueueputemptygetrrr;rZrP)rZ current_graphZbfs_qvisitedrZds_graphZinput_dsr>r>r?r s   r zdata.make_one_shot_iteratorcCs*y|Stk r$t|SXdS)aTCreates an iterator for elements of `dataset`. Note: The returned iterator will be initialized automatically. A "one-shot" iterator does not support re-initialization. Args: dataset: A `tf.data.Dataset`. Returns: A `tf.data.Iterator` for elements of `dataset`. @compatibility(TF2) This is a legacy API for consuming dataset elements and should only be used during transition from TF 1 to TF 2. Note that using this API should be a transient state of your code base as there are in general no guarantees about the interoperability of TF 1 and TF 2 code. In TF 2 datasets are Python iterables which means you can consume their elements using `for elem in dataset: ...` or by explicitly creating iterator via `iterator = iter(dataset)` and fetching its elements via `values = next(iterator)`. @end_compatibility N)rrr)rr>r>r?rsrz data.make_initializable_iteratorcCs.y ||Stk r(t||SXdS)aCreates an iterator for elements of `dataset`. Note: The returned iterator will be in an uninitialized state, and you must run the `iterator.initializer` operation before using it: ```python dataset = ... iterator = tf.compat.v1.data.make_initializable_iterator(dataset) # ... sess.run(iterator.initializer) ``` Args: dataset: A `tf.data.Dataset`. shared_name: (Optional.) If non-empty, the returned iterator will be shared under the given name across multiple sessions that share the same devices (e.g. when using a remote server). Returns: A `tf.data.Iterator` for elements of `dataset`. Raises: RuntimeError: If eager execution is enabled. @compatibility(TF2) This is a legacy API for consuming dataset elements and should only be used during transition from TF 1 to TF 2. Note that using this API should be a transient state of your code base as there are in general no guarantees about the interoperability of TF 1 and TF 2 code. In TF 2 datasets are Python iterables which means you can consume their elements using `for elem in dataset: ...` or by explicitly creating iterator via `iterator = iter(dataset)` and fetching its elements via `values = next(iterator)`. @end_compatibility N)rrr)rrr>r>r?rs& rzdata.experimental.get_structurecCs4y|jStk r.tdt|dYnXdS)a\Returns the type signature for elements of the input dataset / iterator. For example, to get the structure of a `tf.data.Dataset`: >>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3]) >>> tf.data.experimental.get_structure(dataset) TensorSpec(shape=(), dtype=tf.int32, name=None) >>> dataset = tf.data.experimental.from_list([(1, 'a'), (2, 'b'), (3, 'c')]) >>> tf.data.experimental.get_structure(dataset) (TensorSpec(shape=(), dtype=tf.int32, name=None), TensorSpec(shape=(), dtype=tf.string, name=None)) To get the structure of an `tf.data.Iterator`: >>> dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3]) >>> tf.data.experimental.get_structure(iter(dataset)) TensorSpec(shape=(), dtype=tf.int32, name=None) Args: dataset_or_iterator: A `tf.data.Dataset` or an `tf.data.Iterator`. Returns: A (nested) structure of `tf.TypeSpec` objects matching the structure of an element of `dataset_or_iterator` and specifying the type of individual components. Raises: TypeError: If input is not a `tf.data.Dataset` or an `tf.data.Iterator` object. zuInvalid `dataset_or_iterator`. `dataset_or_iterator` must be a `tf.data.Dataset` or tf.data.Iterator object, but got rIN)rrrSrD)dataset_or_iteratorr>r>r? get_structure.s!r&zdata.get_output_classescCstddt|S)aReturns the output classes for elements of the input dataset / iterator. Args: dataset_or_iterator: A `tf.data.Dataset` or `tf.data.Iterator`. Returns: A (nested) structure of Python `type` objects matching the structure of the dataset / iterator elements and specifying the class of the individual components. @compatibility(TF2) This is a legacy API for inspecting the type signature of dataset elements. In TF 2, you should use the `tf.data.Dataset.element_spec` attribute instead. @end_compatibility cSs|S)N)r)rr>r>r?rirz+get_legacy_output_classes..)r rr&)r%r>r>r?rWsrzdata.get_output_shapescCstddt|S)aReturns the output shapes for elements of the input dataset / iterator. Args: dataset_or_iterator: A `tf.data.Dataset` or `tf.data.Iterator`. Returns: A (nested) structure of `tf.TensorShape` objects matching the structure of the dataset / iterator elements and specifying the shape of the individual components. @compatibility(TF2) This is a legacy API for inspecting the type signature of dataset elements. In TF 2, you should use the `tf.data.Dataset.element_spec` attribute instead. @end_compatibility cSs|S)N)r)rr>r>r?rrz*get_legacy_output_shapes..)r rr&)r%r>r>r?remsrezdata.get_output_typescCstddt|S)aReturns the output shapes for elements of the input dataset / iterator. Args: dataset_or_iterator: A `tf.data.Dataset` or `tf.data.Iterator`. Returns: A (nested) structure of `tf.DType` objects matching the structure of dataset / iterator elements and specifying the shape of the individual components. @compatibility(TF2) This is a legacy API for inspecting the type signature of dataset elements. In TF 2, you should use the `tf.data.Dataset.element_spec` attribute instead. @end_compatibility cSs|S)N)r)rr>r>r?rrz)get_legacy_output_types..)r rr&)r%r>r>r?rsrc@seZdZdZddZdS) DatasetSourcez5Abstract class representing a dataset with no inputs.cCsgS)Nr>)rVr>r>r?rPszDatasetSource._inputsN)rrrrrPr>r>r>r?r'sr'cs(eZdZdZfddZddZZS) UnaryDatasetz5Abstract class representing a dataset with one input.cs||_tt||dS)N)_input_datasetrzr(rY)rVrXrW)rr>r?rYszUnaryDataset.__init__cCs|jgS)N)r))rVr>r>r?rPszUnaryDataset._inputs)rrrrrYrPrr>r>)rr?r(s r(cs,eZdZdZfddZeddZZS)UnaryUnchangedStructureDatasetzDRepresents a unary dataset with the same input and output structure.cs||_tt|||dS)N)r)rzr*rY)rVrXrW)rr>r?rYs z'UnaryUnchangedStructureDataset.__init__cCs|jjS)N)r)r)rVr>r>r?rsz+UnaryUnchangedStructureDataset.element_spec)rrrrrYrrrr>r>)rr?r*s r*cs4eZdZdZfddZddZeddZZS)_VariantDatasetz@A Dataset wrapper around a `tf.variant`-typed function argument.cs||_tt||dS)N) _element_specrzr+rY)rVZdataset_variantr)rr>r?rYsz_VariantDataset.__init__cCsgS)Nr>)rVr>r>r?rPsz_VariantDataset._inputscCs|jS)N)r,)rVr>r>r?rsz_VariantDataset.element_spec) rrrrrYrPrrrr>r>)rr?r+s r+c@s eZdZddZeddZdS)_NestedVariantcCs||_||_||_dS)N)rZr,_dataset_shape)rVrWr dataset_shaper>r>r?rYsz_NestedVariant.__init__cCst|j|jS)N)rr,r.)rVr>r>r?rsz_NestedVariant._type_specN)rrrrYrrr>r>r>r?r-sr-zdata.experimental.from_variantcCs t||S)a=Constructs a dataset from the given variant and (nested) structure. Args: variant: A scalar `tf.variant` tensor representing a dataset. structure: A (nested) structure of `tf.TypeSpec` objects representing the structure of each element in the dataset. Returns: A `tf.data.Dataset` instance. )r+)rr r>r>r? from_variants r0zdata.experimental.to_variantcCs|jS)zReturns a variant representing the given dataset. Args: dataset: A `tf.data.Dataset`. Returns: A scalar `tf.variant` tensor representing the given dataset. )rZ)rr>r>r? to_variants r1zdata.DatasetSpecz"data.experimental.DatasetStructurec@seZdZdZddgZd,ddZeddZed d Zd d Z d dZ ddZ eddZ ddZ ddZddZeddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+S)-ra$Type specification for `tf.data.Dataset`. See `tf.TypeSpec` for more information about TensorFlow type specifications. >>> dataset = tf.data.Dataset.range(3) >>> tf.data.DatasetSpec.from_value(dataset) DatasetSpec(TensorSpec(shape=(), dtype=tf.int64, name=None), TensorShape([])) r,r.r>cCs||_t||_dS)N)r,rrr.)rVrr/r>r>r?rYszDatasetSpec.__init__cCstS)N)r)rVr>r>r?rCszDatasetSpec.value_typecCs|jS)zThe inner element spec.)r,)rVr>r>r?rszDatasetSpec.element_specc Cst|t|k rdSyt|j|jWnttfk r@dSXt|j}t|j}dd}x$t||D]\}}|||sndSqnW|j |jS)zSee base class.FcSs"t|tjr||S||kSdS)N)rAr+ TraceType is_subtype_of)abr>r>r?is_subtype_or_equals  z6DatasetSpec.is_subtype_of..is_subtype_or_equal) rDtf_nestassert_same_structurerrSr;rrr.r3)rVotherZ self_elementsZother_elementsr6Z self_elementZ other_elementr>r>r?r3 s   zDatasetSpec.is_subtype_ofc s tfdd|DsdSy"x|D]}tj|jq"WWnttfk rTdSXtj}dd|D}dgt|}dd}xHt|D]<\}||fdd|D|<|dk r|dkrdSqWt j |}j d d|D} | dkrdSt || S) zSee base class.c3s|]}tt|kVqdS)N)rD)rdr9)rVr>r?r'sz=DatasetSpec.most_specific_common_supertype..NcSsg|]}t|jqSr>)r7rr)rdr9r>r>r?rh2sz>DatasetSpec.most_specific_common_supertype..cs8ttjr|Stfdd|Dr0SdSdS)Nc3s|]}|kVqdS)Nr>)rdr5)r4r>r?r:sz`DatasetSpec.most_specific_common_supertype..common_supertype_or_equal..)rAr+r2most_specific_common_supertyper)r4bsr>)r4r?common_supertype_or_equal6s  zMDatasetSpec.most_specific_common_supertype..common_supertype_or_equalcsg|] }|qSr>r>)rdZother_components)rer>r?rh?scSsg|] }|jqSr>)r.)rdr9r>r>r?rhFs)rr7r8rrSr;rrrqrr,r.r:r) rVZothersr9Zself_componentsZothers_componentsZcommon_componentsr<Zself_componentZcommon_element_specZcommon_dataset_shaper>)rerVr?r:%s0   z*DatasetSpec.most_specific_common_supertypecCs |j|jfS)N)r,r.)rVr>r>r? _serializeOszDatasetSpec._serializecCst|jtjS)N)rrr.rr)rVr>r>r?_component_specsRszDatasetSpec._component_specscCs|jS)N)rZ)rVrEr>r>r?_to_componentsVszDatasetSpec._to_componentscCs,|jjdkrt||jSt||j|jSdS)Nr)r.rr+r,r-)rV componentsr>r>r?_from_componentsYs  zDatasetSpec._from_componentscCsttdd|gS)NcSs|jS)N)rZ)rr>r>r?rcrz-DatasetSpec._to_tensor_list..)rr8r7r)rVrEr>r>r?_to_tensor_list`szDatasetSpec._to_tensor_listcCs t|jS)z>Creates a `DatasetSpec` for the given `tf.data.Dataset` value.)rr)rEr>r>r? from_valuefszDatasetSpec.from_valuecCst|jt|g|jS)N)rr,rrr$r.)rVr+r>r>r?_batchkszDatasetSpec._batchcCs*|jjdkrtdt|j|jddS)Nrz5Slicing dataset elements is not supported for rank 0.r)r.rr;rr,)rVr>r>r?_unbatchps zDatasetSpec._unbatchcCs|jjdkrtd||S)Nrz5Slicing dataset elements is not supported for rank 0.)r.rr;rB)rVrEr>r>r?_to_batched_tensor_listus z#DatasetSpec._to_batched_tensor_listcCs|S)Nr>)rVr>r>r?rzsz#DatasetSpec._to_legacy_output_typescCs|S)Nr>)rVr>r>r?r}sz$DatasetSpec._to_legacy_output_shapescCs|S)Nr>)rVr>r>r?rsz%DatasetSpec._to_legacy_output_classescCsttS)N)hashr)rVr>r>r?__hash__szDatasetSpec.__hash__cCs"t|to |j|jko |j|jkS)N)rArr,r.)rVr9r>r>r?__eq__s  zDatasetSpec.__eq__N)r>)rrrr __slots__rYrrCrr3r:r=r>r?rArBrrCrDrErFrrrrHrIr>r>r>r?rs*    *  rc@s6eZdZdZdgZddZddZddZd d Zd S) rz9Iterator over a dataset with elements converted to numpy. _iteratorcCst||_dS)N)rrK)rVrr>r>r?rYsz_NumpyIterator.__init__cCs|S)Nr>)rVr>r>r?rsz_NumpyIterator.__iter__cCsdd}t|t|jS)NcSs$|}t|tjr |jdd|S)NF)write)Z_numpyrArrZsetflags)rrpr>r>r?to_numpys  z)_NumpyIterator.__next__..to_numpy)r rrrK)rVrMr>r>r?__next__sz_NumpyIterator.__next__cCs|S)N)rN)rVr>r>r?rsz_NumpyIterator.nextN) rrrrrJrYrrNrr>r>r>r?rs  rcs4eZdZdZfddZejjffdd ZZ S)r|a`Allows export of functions capturing a Dataset in SavedModels. When saving a SavedModel, `tf.saved_model.save` traverses the object graph. Since Datasets reference _VariantTracker objects, that traversal will find a _VariantTracker for each Dataset and so know how to save and restore functions which reference the Dataset's variant Tensor. cs6tt|jdd||_t|tjs,td||_dS)aRecord that `variant_tensor` is associated with `resource_creator`. Args: variant_tensor: The variant-dtype Tensor associated with the Dataset. This Tensor will be a captured input to functions which use the Dataset, and is used by saving code to identify the corresponding _VariantTracker. resource_creator: A zero-argument function which creates a new variant-dtype Tensor. This function will be included in SavedModels and run to re-create the Dataset's variant Tensor on restore. ra)rmz1Resource creator should already be a tf.function.N) rzr|rYZ_resource_handlerAr1FunctionrS_create_resource)rVrWZresource_creator)rr>r?rYs  z_VariantTracker.__init__c s2|tjjkriStt|j|f|}|j|d<|S)NrP)rwrxryrzr|r{rP)rVr}r~r)rr>r?r{s   z#_VariantTracker._trackable_children) rrrrrYrwrxrr{rr>r>)rr?r|s r|cs.eZdZdZdfdd ZeddZZS)rz"A `Dataset` with a single element.Ncs`t|}t||_t|j||_||_tj|jt |j|j d}t t ||dS)z)See `Dataset.from_tensors()` for details.)rrN)r rr _structurerZ_tensorsrrZtensor_datasetrrrnrzrrY)rVelementr=rW)rr>r?rYs   zTensorDataset.__init__cCs|jS)N)rQ)rVr>r>r?rszTensorDataset.element_spec)N)rrrrrYrrrr>r>)rr?rs rcs,eZdZdZfddZeddZZS)rzHA `Dataset` that splits a rank-N `tf.sparse.SparseTensor` into its rows.cst|tjs tdt|d||_|jj}|jj}|j dd |j dd}t d|gt jt dg|jjt |gt jf|_t|jj|jj|jj}tt||dS)z6See `Dataset.from_sparse_tensor_slices()` for details.zQInvalid `sparse_tensor`. `sparse_tensor` must be a `tf.sparse.SparseTensor`. Got rIrrN)rArZ SparseTensorrSrDZ_sparse_tensorindices get_shapeZ dense_shapedims merge_withrrrrrrQrZsparse_tensor_slice_datasetrrzrrY)rVrZ indices_shapeZ shape_shapeZrankrW)rr>r?rYs     z!SparseTensorSliceDataset.__init__cCs|jS)N)rQ)rVr>r>r?rsz%SparseTensorSliceDataset.element_spec)rrrrrYrrrr>r>)rr?rs rcs6eZdZdZd fdd ZeddZddZZS) rz;A `Dataset` that generates elements by invoking a function.Ncs||_t||_tj|||jd|_tj|||jjd|_ tj|||jjd|_ ||_ ||_ t jt|j|j|jjj|j jj|j jjf|jj|j j|j jd|j}tt||dS)aConstructs a `_GeneratorDataset`. Args: init_args: A (nested) structure representing the arguments to `init_func`. init_func: A TensorFlow function that will be called on `init_args` each time a C++ iterator over this dataset is constructed. Returns a (nested) structure representing the "state" of the dataset. next_func: A TensorFlow function that will be called on the result of `init_func` to produce each element, and that raises `OutOfRangeError` to terminate iteration. finalize_func: A TensorFlow function that will be called on the result of `init_func` immediately before a C++ iterator over this dataset is destroyed. The return value is ignored. output_signature: A (nested) structure of `tf.TypeSpec` objects describing the output of `next_func`. name: Optional. A name for the tf.data transformation. )r) init_func next_func finalize_funcN)Z _init_argsr rZ_init_structurerr_transformation_nameZ _init_funcoutput_structureZ _next_funcZ_finalize_func_output_signaturerrZgenerator_datasetrrrrrzrrY)rVZ init_argsrWrXrYr r=rW)rr>r?rYs4      z_GeneratorDataset.__init__cCs|jS)N)r\)rVr>r>r?r?sz_GeneratorDataset.element_speccCsdS)NzDataset.from_generator()r>)rVr>r>r?rZCsz&_GeneratorDataset._transformation_name)N) rrrrrYrrrZrr>r>)rr?rs4 rcs6eZdZdZd fdd ZddZeddZZS) r!z*A `Dataset` that zips its inputs together.NcsxDt|D]6}t|ts t|tr.tdq tdt|dq W||_t|jddt|jD|_ ||_ t j ddt|jDf|j }tt||dS)z See `Dataset.zip()` for details.zInvalid `datasets`. `datasets` is expected to be a (nested) structure of `tf.data.Dataset` objects. Python `list` is not supported and you should use `tuple` instead.zInvalid `datasets`. `datasets` is expected to be a (nested) structure of `tf.data.Dataset` objects but encountered object of type rIcSsg|] }|jqSr>)r)rdrr>r>r?rhZsz'ZipDataset.__init__..cSsg|] }|jqSr>)rZ)rdrr>r>r?rh]sN)r rrArGr rSrD _datasetsrrQrrZ zip_datasetrrzr!rY)rVr"r=rrW)rr>r?rYJs   zZipDataset.__init__cCs t|jS)N)r rr])rVr>r>r?rPaszZipDataset._inputscCs|jS)N)rQ)rVr>r>r?rdszZipDataset.element_spec)N) rrrrrYrPrrrr>r>)rr?r!Gsr!cs6eZdZdZd fdd ZddZeddZZS) r#z;A `Dataset` that concatenates its input with given dataset.Nc s||_||_dd}yt||j|j|_Wn@ttfk rl}ztd|jd|j|Wdd}~XYnX||g|_||_ t j |j |j f|j }tt||dS)z(See `Dataset.concatenate()` for details.cSs.||g}|dkr*td|d|d|S)NzNo common supertype of z and rI)r:rS)r4r5resultr>r>r?common_supertypeqs z5ConcatenateDataset.__init__..common_supertypez!Incompatible dataset elements: z vs. N)r)Z_dataset_to_concatenater7rrrQrSr;rzrrZconcatenate_datasetrZrrzr#rY)rVrXZdataset_to_concatenater=r_rrW)rr>r?rYls"  zConcatenateDataset.__init__cCs|jS)N)rz)rVr>r>r?rPszConcatenateDataset._inputscCs|jS)N)rQ)rVr>r>r?rszConcatenateDataset.element_spec)N) rrrrrYrPrrrr>r>)rr?r#isr#cs"eZdZdZdfdd ZZS)rBz1A `Dataset` that repeats its input several times.Ncsp||_|dkr$tjdtjdd|_ntj|tjdd|_||_t j |j fd|ji|j }t t|||dS)z#See `Dataset.repeat()` for details.Nr4rC)rr=)r)rrrr_countrr8rrZrepeat_datasetrZrrzrBrY)rVrXrCr=rW)rr>r?rYs zRepeatDataset.__init__)N)rrrrrYrr>r>)rr?rBsrBcs<eZdZdZfddZddZddZedd ZZ S) rz0A `Dataset` of a step separated range of values.csP|j||tg|j|_tjf|j|j|j d|j }t t | |dS)z"See `Dataset.range()` for details.)r'stopr(N) _parse_argsrr _output_typerQrrI_start_stop_steprrzrrY)rVrr~rW)rr>r?rYs  zRangeDataset.__init__cOs t|dkr<|dd|_||dd|_|dd|_nt|dkr|||dd|_||dd|_|dd|_nXt|dkr||dd|_||dd|_||dd|_ntdt|d d |kr|d |_ntj|_d |kr|d nd |_ d S) zEParse arguments according to the same rules as the `range()` builtin.rrr'rar(rrzGInvalid `args`. The lenght of `args` should be between 1 and 3 but was rI output_typer=N) r _build_tensorrdrerfr;rcrrr)rVrr~r>r>r?rbs"    zRangeDataset._parse_argscCstj|tj|dS)N)rr=)rr8rr)rVZ int64_valuer=r>r>r?rhszRangeDataset._build_tensorcCs|jS)N)rQ)rVr>r>r?rszRangeDataset.element_spec) rrrrrYrbrhrrrr>r>)rr?rs  rcs"eZdZdZdfdd ZZS)rMz.A `Dataset` that caches elements of its input.Ncs||_tj|tjdd|_||_tr\t s8t r\t j |jf|jt d|j}nt j|jfd|ji|j}tt|||dS)z"See `Dataset.cache()` for details.rN)rr=)rNrON)r)rr8rro _filenamerrrr rrrZcache_dataset_v2rZZdummy_memory_cacherZ cache_datasetrzrMrY)rVrXrNr=rW)rr>r?rYs   zCacheDataset.__init__)N)rrrrrYrr>r>)rr?rMsrMcs"eZdZdZdfdd ZZS)rJz=A `Dataset` that randomly shuffles the elements of its input.Ncs||_tj|tjdd|_t|\|_|_ |dkr8d}||_ ||_ t rts\trtj|jf|j|j|j t|j d|j}n(tj|jf|j|j|j |j d|j}tt|||dS)z$See `Dataset.shuffle()` for details.r.)rr=NT)r.r6seed2Zseed_generatorrK)r.r6rjrK)r)rr8rr _buffer_sizer r _seed_seed2Z_reshuffle_each_iterationrrrr rrrZshuffle_dataset_v3rZZdummy_seed_generatorrZshuffle_datasetrzrJrY)rVrXr.r6rKr=rW)rr>r?rYs4  zShuffleDataset.__init__)NNN)rrrrrYrr>r>)rr?rJsrJcs"eZdZdZdfdd ZZS)rPzAA `Dataset` containing the first `count` elements from its input.NcsR||_tj|tjdd|_||_tj|j fd|ji|j }t t | ||dS)z!See `Dataset.take()` for details.rC)rr=N)r)rr8rrr`rrZ take_datasetrZrrzrPrY)rVrXrCr=rW)rr>r?rYs zTakeDataset.__init__)N)rrrrrYrr>r>)rr?rPsrPcs"eZdZdZdfdd ZZS)rRz?A `Dataset` skipping the first `count` elements from its input.NcsR||_tj|tjdd|_||_tj|j fd|ji|j }t t | ||dS)z!See `Dataset.skip()` for details.rC)rr=N)r)rr8rrr`rrZ skip_datasetrZrrzrRrY)rVrXrCr=rW)rr>r?rY#s zSkipDataset.__init__)N)rrrrrYrr>r>)rr?rR srRcs"eZdZdZdfdd ZZS)rTz#A `Dataset` for sharding its input.Ncsj||_tj|tjdd|_tj|tjdd|_||_tj |j f|j|jd|j }t t |||dS)z"See `Dataset.shard()` for details.rU)rr=rV)rUrVN)r)rr8rrZ _num_shards_indexrrZ shard_datasetrZrrzrTrY)rVrXrUrVr=rW)rr>r?rY2s zShardDataset.__init__)N)rrrrrYrr>r>)rr?rT/srTcs.eZdZdZdfdd ZeddZZS)r`zr?rTrz'BatchDataset.__init__..cSs |dS)N)rD)rr>r>r?rXr)r+r,N)r)rr8rr _batch_sizebool_drop_remainderrrr rrrQrrZbatch_dataset_v2rZrrzr`rY)rVrXr+r,r=constant_drop_remainderrW)r)ror?rYDs*      zBatchDataset.__init__cCs|jS)N)rQ)rVr>r>r?rcszBatchDataset.element_spec)N)rrrrrYrrrr>r>)rr?r`Asr`cs.eZdZdZdfdd ZeddZZS)razHA `Dataset` that batches contiguous elements from its input in parallel.Nc s||_tj|tjdd|_tj|tjdd|_tj|tjdd|_|dkrRd|_ n|r^d|_ nd|_ t |j}|rt |jt fd d |j|_nt d d |j|_||_tj|jf|j|j|j|j d |j}tt|||dS) z"See `Dataset.batch()` for details.r+)rr=r,rbNdefaulttruefalsecs |S)N)rD)r)ror>r?rrz/ParallelBatchDataset.__init__..cSs |dS)N)rD)rr>r>r?rr)r+rbr,rc)r)rr8rrrprqrr_num_parallel_calls_deterministicrrr rrrQrrZparallel_batch_datasetrZrrzrarY) rVrXr+r,rbrcr=rsrW)r)ror?rYks<      zParallelBatchDataset.__init__cCs|jS)N)rQ)rVr>r>r?rsz!ParallelBatchDataset.element_spec)N)rrrrrYrrrr>r>)rr?rahs*racCst|jdks|jdkrdSt|jt|jkr0dSx>t|j|jD],\}}|jdk r@|jdk r@|j|jkr@dSq@WdS)aReturns `True` if `input_component_shape` can be padded to `padded_shape`. Args: padded_shape: A `tf.TensorShape`. input_component_shape: A `tf.TensorShape`. Returns: `True` if `input_component_shape` can be padded to `padded_shape`, otherwise `False`. NTF)rUrrrE) padded_shapeinput_component_shapeZ padded_dimZ input_dimr>r>r? _is_padded_shape_compatible_withs  r{c Csy,t|}tjdd|Dtjd}Wnttfk r}z|tj|tjd}|j j dk rt |j j dkrtd|d|j d ||j tjkrtd|d |j j d |t|}Wdd}~XYnXt||std |d |d |S)aSConverts `padded_shape` to a `tf.Tensor` representing that shape. Args: padded_shape: A shape-like object, which may be a `tf.TensorShape`, a Python sequence, or a 1-D `tf.Tensor` of `tf.int64` elements. input_component_shape: A `tf.TensorShape`, with which `padded_shape` must be compatible. Returns: A 1-D `tf.Tensor` of `tf.int64` elements, representing `padded_shape`. Raises: ValueError: If `padded_shape` is not a shape or not compatible with `input_component_shape`. TypeError: If `padded_shape` is not convertible to a `tf.int64` tensor. cSsg|]}|dk r|ndqS)Nr4r>)rddimr>r>r?rhsz+_padded_shape_to_tensor..)r)Zpreferred_dtypeNrz Padded shape z7 must be a `tf.int64` vector tensor, but its shape was rIz> must be a `tf.int64` vector tensor, but its element type was zThe padded shape z" is not compatible with the shape z& of the corresponding input component.)rrrr8rrrrSr;rrUrrr=rconstant_value_as_shaper{)ryrzZpadded_shape_as_shaperrr>r>r?_padded_shape_to_tensors(  r~cCsXtj|dd}|jtgs2td|jd|j|krTtd|jd|d|S)a#Converts the padding value to a tensor. Args: value: The padding value. output_type: Its expected dtype. Returns: A scalar `Tensor`. Raises: ValueError: if the padding value is not a scalar. TypeError: if the padding value's type does not match `output_type`. Z padding_value)r=zMInvalid `padding_values`. `padding_values` values should be scalars, but got rIz7Invalid `padding_values`. `padding_values` values type z does not match type z& of the corresponding input component.) rr8rrrrr;rrS)rErgr>r>r?_padding_value_to_tensors  rcCs0dd}dd}t|t|}t||||S)zGReturns padding values with None elements replaced with default values.cSsT|jtjkrdS|jtjkr&tdn*|jtjkrBtjdtjdSt | SdS)NrLzIUnable to create default padding value for a component of type 'variant'.r)r) Z base_dtyperrorrSZbfloat16rrrZ zeros_liker)tr>r>r? make_zeros    z-_padding_values_or_default..make_zerocSs|dkr |S|S)Nr>)rErtr>r>r?value_or_defaultsz4_padding_values_or_default..value_or_default)r rrr)rhrXrrZdefault_paddingr>r>r?_padding_values_or_defaults  rcs.eZdZdZdfdd ZeddZZS)rfzEA `Dataset` that batches and pads contiguous elements from its input.Nc s~|_dd}t||j|_tj|tjdd_t |t |}t ||} g} x,t t || D]\} } | t| | qjWt|| _t|rtstfdd|t|tt|_tj|tjdd_fdd } t| j}ttj|tj_|_tj|j jd d t jDt jjt!jj"#d }t$t%&||d S)z"See `Dataset.batch()` for details.cSs t|tjstd|ddS)Nzq`padded_batch` is only supported for datasets that produce tensor elements but the input dataset spec contains: `z`.)rArrrS)rr>r>r? check_types(s z0PaddedBatchDataset.__init__..check_typesr+)rr=csS)Nr>)r[)rhr>r?rDrz-PaddedBatchDataset.__init__..r,cs0ttjrtjndgt |S)N) rrrZsmart_constant_valuerrrrrpr$r})s)rVr>r?_padded_shape_to_batch_shapeMs zAPaddedBatchDataset.__init__.._padded_shape_to_batch_shapecSsg|]}tj|tjdqS))r)rr8rr)rdrr>r>r?rh_sz/PaddedBatchDataset.__init__..)r+rgrhr,rrN)'r)r rrrr8rrrprrerrrrr~rZ_padded_shapesZ is_nestedrrrZ_padding_valuesrqrrr rrrQrrZpadded_batch_dataset_v2rZrrrnrzrfrY)rVrXr+rgrhr,r=rrZflat_padded_shapesZflat_padded_shapes_as_tensorsrzryrrrW)r)rhrVr?rYsR        zPaddedBatchDataset.__init__cCs|jS)N)rQ)rVr>r>r?rhszPaddedBatchDataset.element_spec)N)rrrrrYrrrr>r>)rr?rfsDrfcs>eZdZdZd fdd ZddZed d Zd d ZZ S)rkzr?rYps"   zMapDataset.__init__cCs|jgS)N)r)rVr>r>r?rszMapDataset._functionscCs|jjS)N)rr[)rVr>r>r?rszMapDataset.element_speccCsdS)Nz Dataset.map()r>)rVr>r>r?rZszMapDataset._transformation_name)TFFN) rrrrrYrrrrZrr>r>)rr?rkms rkcs>eZdZdZd fdd ZddZed d Zd d ZZ S)rlzHA `Dataset` that maps a function over elements in its input in parallel.TFNc s||_||_tj||||d|_|dkr4d|_n|r@d|_nd|_||_tj |t j dd|_ ||_ tj|j|jjjf|jj|j |j|j|jd|j} tt||| dS) z See `Dataset.map()` for details.)rrNrtrurvrb)rr=)rrbrcrrj)r)rrrrZrrxrrr8rrrwrrZparallel_map_dataset_v2rZrrrrzrlrY) rVrXrmrbrcrrjrr=rW)rr>r?rYs4    zParallelMapDataset.__init__cCs|jgS)N)r)rVr>r>r?rszParallelMapDataset._functionscCs|jjS)N)rr[)rVr>r>r?rszParallelMapDataset.element_speccCsdS)Nz Dataset.map()r>)rVr>r>r?rZsz'ParallelMapDataset._transformation_name)TFFN) rrrrrYrrrrZrr>r>)rr?rls rlcs>eZdZdZd fdd ZddZeddZd d ZZ S) rozHA `Dataset` that maps a function over its input and flattens the result.Ncs||_tj|||d|_t|jjtsBtdt |jjd|jjj |_ ||_ t j|j|jjjfd|jji|j}tt|||dS)z%See `Dataset.flat_map()` for details.)rzr?rYs   zFlatMapDataset.__init__cCs|jgS)N)r)rVr>r>r?rszFlatMapDataset._functionscCs|jS)N)rQ)rVr>r>r?rszFlatMapDataset.element_speccCsdS)NzDataset.flat_map()r>)rVr>r>r?rZsz#FlatMapDataset._transformation_name)N) rrrrrYrrrrZrr>r>)rr?ros  rocs>eZdZdZd fdd ZddZeddZd d ZZ S) rrz>A `Dataset` that interleaves the result of transformed inputs.Ncs||_tj|||d|_t|jjtsBtdt |jjd|jjj |_ t j |tjdd|_t j |tjdd|_||_tj|j|jjj|j|jfd|jji|j}tt|||dS) z'See `Dataset.interleave()` for details.)rzr?rYs(  zInterleaveDataset.__init__cCs|jgS)N)r)rVr>r>r?r szInterleaveDataset._functionscCs|jS)N)rQ)rVr>r>r?r szInterleaveDataset.element_speccCsdS)NzDataset.interleave()r>)rVr>r>r?rZsz&InterleaveDataset._transformation_name)N) rrrrrYrrrrZrr>r>)rr?rrs  rrcsFeZdZdZeeddffdd ZddZeddZd d Z Z S) rszKA `Dataset` that maps a function over its input and interleaves the result.Nc s&||_tj|||d|_t|jjtsBtdt |jjd|jjj |_ t j |tjdd|_t j |tjdd|_t j |tjdd|_t j |tjdd|_t j |tjd d|_|d krd } n|rd } nd } | |_tj|j|jjj|j|j|j|j|jf|jj| d|j} tt||| d S)z'See `Dataset.interleave()` for details.)rzr?rYsP      z"ParallelInterleaveDataset.__init__cCs|jgS)N)r)rVr>r>r?rPsz$ParallelInterleaveDataset._functionscCs|jS)N)rQ)rVr>r>r?rSsz&ParallelInterleaveDataset.element_speccCsdS)NzDataset.interleave()r>)rVr>r>r?rZWsz.ParallelInterleaveDataset._transformation_name) rrrrr5rYrrrrZrr>r>)rr?rss/ rscs"eZdZdZdfdd ZZS)r-z5A `Dataset` that asynchronously prefetches its input.Nc sx||_|dkrt}tj|tjdd|_||_t|j $t j |j f|j|d|j }WdQRXt t|||dS)z%See `Dataset.prefetch()` for details.Nr.)rr=)r. slack_period)r)r5rr8rrrkrrrZrZprefetch_datasetrrzr-rY)rVrXr.rr=rW)rr>r?rY^szPrefetchDataset.__init__)NN)rrrrrYrr>r>)rr?r-[sr-cs.eZdZdZdfdd ZeddZZS)r}z?A dataset that creates window datasets from the input elements.Nc s||_tj|tjdd|_tj|tjdd|_tj|tjdd|_tj|tjdd|_ t t |ddt t t |t t|t t|D|_||_tj|jf|j|j|j|j d|j}tt|||d S) z See `window()` for more details.r~)rr=rrr,cSs$g|]\}}}tt|||qSr>)rr r)rdZ output_classZ output_shapergr>r>r?rhsz*WindowDataset.__init__..)r~rrr,N)r)rr8rr_sizeZ_shiftZ_striderqrrr rrrrrerrQrrZwindow_datasetrZrrzr}rY)rVrXr~rrr,r=rW)rr>r?rYus.   zWindowDataset.__init__cCs|jS)N)rQ)rVr>r>r?rszWindowDataset.element_spec)N)rrrrrYrrrr>r>)rr?r}rsr}cs"eZdZdZdfdd ZZS)rz*An identity `Dataset` that stores options.Nc s||_t}||||_t|jt j |j| f|j }WdQRXt t||||jr|jd|j||_n||_|jddS)NTF)r)rrNZCopyFromZ _to_protorrrrZrZoptions_datasetrnrrzrrYrOrUrT)rVrXrr=Z options_pbrW)rr>r?rYs  z_OptionsDataset.__init__)N)rrrrrYrr>r>)rr?rsrcs<tjrfdd}n fdd}|}t|jS)a~Normalizes non-tensor components in a dataset to dense representations. This is necessary for dataset transformations that slice along the batch dimension and are oblivious to non-tensors, e.g. `unbatch`, `rebatch`. Args: dataset: Dataset to normalize. Returns: A dataset whose sparse and ragged tensors have been normalized to their dense representations. cstjt|S)N)r to_batched_tensor_listrr )r)rr>r? normalizesz%normalize_to_dense..normalizecstj|S)N)r rr)arg)rr>r?rs)rZ_should_unpackrrn_RestructuredDataset)rrrr>)rr?rs    rcs,eZdZdZfddZeddZZS)rz>An internal helper for changing the element spec of a dataset.cs*||_||_|jj}tt|||dS)N)r)r,rZrzrrY)rVrrrW)rr>r?rYsz_RestructuredDataset.__init__cCs|jS)N)r,)rVr>r>r?rsz!_RestructuredDataset.element_spec)rrrrrYrrrr>r>)rr?rs rcs.eZdZdZdfdd ZeddZZS)rzGA dataset that splits the elements of its input into multiple elements.Nc s|j}tdd|Dr tdtd}xN|D]F}y||d}Wq0tk rttd|d|ddYq0Xq0W||_td d t ||_ ||_ t j |jjf|j}tt|||dS) z!See `unbatch()` for more details.css|]}|jdkVqdS)rN)r)rdrr>r>r?rsz+_UnbatchDataset.__init__..z/Cannot unbatch an input with scalar components.Nrz|`unbatch()` is only supported for datasets of elements whose components have a matching leading dimension. Encountered both z and rIcSs|S)N)rE)rr>r>r?rrz*_UnbatchDataset.__init__..)ranyr;rZ DimensionrVr)r rr&rQrged_opsZunbatch_datasetrZrrzrrY)rVrXr=Z flat_shapesZknown_batch_dimrrW)rr>r?rYs$  $ z_UnbatchDataset.__init__cCs|jS)N)rQ)rVr>r>r?rsz_UnbatchDataset.element_spec)N)rrrrrYrrrr>r>)rr?rsrcsVeZdZdZdfdd ZddZddZd d Zed d Z d dZ ddZ Z S)rzDA `Dataset` that groups its input and performs a windowed reduction.Ncs||_||||||||||_tj|jj|jj j |j j j |j j j f|jj |j j |j j d|j }tt|||dS)z$See `group_by_window()` for details.)rrrN)r)_make_key_func_make_reduce_func_make_window_size_funcrrZgroup_by_window_datasetrZ _key_funcrr _reduce_func_window_size_funcrrzrrY)rVrXrrrr=rW)rr>r?rYs      z_GroupByWindowDataset.__init__cs\fdd}tj||tgtjd|_|jj tgtjsXt d|jjddS)z)Make wrapping defun for window_size_func.cstj|tjdS)N)r)rr8rr)r)rr>r?window_size_func_wrapper!szN_GroupByWindowDataset._make_window_size_func..window_size_func_wrapper)rztInvalid `window_size_func`. `window_size_func` must return a single `tf.int64` scalar tensor but its return type is rIN) rrrZrrrrrr[rr;)rVrrr>)rr?rs z,_GroupByWindowDataset._make_window_size_funccsRfdd}tj|||d|_|jjtgtj sNt d|jjddS)z!Make wrapping defun for key_func.cstj|tjdS)N)r)rr8rr)r)rr>r?key_func_wrapper2sz>_GroupByWindowDataset._make_key_func..key_func_wrapper)rzdInvalid `key_func`. `key_func` must return a single `tf.int64` scalar tensor but its return type is rIN) rrrZrr[rrrrrr;)rVrrXrr>)rr?r/s  z$_GroupByWindowDataset._make_key_funccCsdt|j}tgtj|f}tj|||d|_ t |j j tsTt d|j j d|j j j |_ dS)z$Make wrapping defun for reduce_func.)rzjInvalid `reduce_func`. `reduce_func` must return a single `tf.data.Dataset` object but its return type is rIN)rrrrrrrrrZrrAr[rSr,)rVrrXZnested_datasetrr>r>r?r=s  z'_GroupByWindowDataset._make_reduce_funccCs|jS)N)r,)rVr>r>r?rLsz"_GroupByWindowDataset.element_speccCs|j|j|jgS)N)rrr)rVr>r>r?rPsz _GroupByWindowDataset._functionscCsdS)NzDataset.group_by_window()r>)rVr>r>r?rZSsz*_GroupByWindowDataset._transformation_name)N) rrrrrYrrrrrrrZrr>r>)rr?rs rcs.eZdZdZdfdd ZeddZZS)rz#A `Dataset` of pseudorandom values.NcsHt|\|_|_||_tjf|j|jd|j}tt | |dS)z#A `Dataset` of pseudorandom values.)r6rjN) r r rlrmrrZrandom_datasetrrzrrY)rVr6r=rW)rr>r?rYZs zRandomDataset.__init__cCstgtjS)N)rrrr)rVr>r>r?rbszRandomDataset.element_spec)NN)rrrrrYrrrr>r>)rr?rWsrcCs:t|}t|}|dks$|dkr(dSt||SdS)aReturns the static probability of sampling from the original. `tensor_util.constant_value(prob_of_original)` returns `None` if it encounters an Op that it isn't defined for. We have some custom logic to avoid this. Args: initial_dist_t: A tensor of the initial distribution. target_dist_t: A tensor of the target distribution. Returns: The probability of sampling from the original distribution as a constant, if it is a constant, or `None`. N)rrrr)rrZ init_staticZ target_staticr>r>r?rgs   rc sxdd}tj||f|dj||d}fdd}tj||f|dj||d}fdd} |j| |d} | jdd |dS) a[Filters a dataset based on per-class acceptance probabilities. Args: dataset: The dataset to be filtered. acceptance_dist_ds: A dataset of acceptance probabilities. initial_dist_ds: A dataset of the initial probability distribution, given or estimated. class_func: A function mapping an element of the input dataset to a scalar `tf.int32` tensor. Values should be in `[0, num_classes)`. seed: (Optional.) Python integer seed for the resampler. name: (Optional.) A name for the tf.data operation. Returns: A dataset of (class value, data) after filtering. cs<tdttdfddfddS)Nrg?csS)Nr>r>) accept_distr>r?rrzC_filter_ds..maybe_warn_on_large_rejection..cstjgddddS)Nz4Proportion of examples rejected by sampler is high: d )r3r5Zfirst_n)r"ZPrintr>)rrproportion_rejectedr>r?rs )r# reduce_sumrZcondr)rrr>)rrrr?maybe_warn_on_large_rejections   z1_filter_ds..maybe_warn_on_large_rejection)r=cs.t|tr|}n|}|t|||fS)N)rAr rgather)Zacceptance_probdataZ class_val)rr>r?_gather_and_copys  z$_filter_ds.._gather_and_copycstjg|jd|kS)N)r6r)r$Zrandom_uniformr)Zunused_class_valr unused_data)r6r>r?_rejectsz_filter_ds.._rejectcSs||fS)Nr>)Z class_valuer[rr>r>r?rrz_filter_ds..)rGrrnrx) rrrrr6r=rrZ+current_probabilities_and_class_and_data_dsrrr>)rr6r?r~s     r rc s^|jdpt|d}t|gt|}fdd}|j|dj|||dj|d}|S)Nrcs.t||\}}tt|ddg}||fS)Nrr)_estimate_data_distributionrZtiler)num_examples_per_class_seencZupdated_examples_per_class_seendistZ tiled_dist)dist_estimation_batch_sizer>r?update_estimate_and_tiles  z;_estimate_initial_dist_ds..update_estimate_and_tile)r=)rrfillrrrdrr) rZclass_values_dsrZsmoothing_constantr= num_classesZinitial_examples_per_class_seenrrr>)rr?rs  rcCs|t|jjj}||S)N)rZfinforrZtiny) initial_probs target_probsdenomr>r>r?_get_target_to_initial_ratiosrc CsV|d}t|ttj||tjdd}t|t|}t |tj }||fS)aEstimate data distribution as labels are seen. Args: c: The class labels. Type `int32`, shape `[batch_size]`. num_examples_per_class_seen: Type `int64`, shape `[num_classes]`, containing counts. Returns: num_examples_per_lass_seen: Updated counts. Type `int64`, shape `[num_classes]`. dist: The updated distribution. Type `float32`, shape `[num_classes]`. r)r) rTr#r:rrZone_hotrrtruedivrr)rrrZinit_prob_estimaterr>r>r?rs  rcCs:t||}t|}t|}|}||||}||fS)aCalculates the acceptance probabilities and mixing ratio. In this case, we assume that we can *either* sample from the original data distribution with probability `m`, or sample from a reshaped distribution that comes from rejection sampling on the original distribution. This rejection sampling is done on a per-class basis, with `a_i` representing the probability of accepting data from class `i`. This method is based on solving the following analysis for the reshaped distribution: Let F be the probability of a rejection (on any example). Let p_i be the proportion of examples in the data in class i (init_probs) Let a_i is the rate the rejection sampler should *accept* class i Let t_i is the target proportion in the minibatches for class i (target_probs) ``` F = sum_i(p_i * (1-a_i)) = 1 - sum_i(p_i * a_i) using sum_i(p_i) = 1 ``` An example with class `i` will be accepted if `k` rejections occur, then an example with class `i` is seen by the rejector, and it is accepted. This can be written as follows: ``` t_i = sum_k=0^inf(F^k * p_i * a_i) = p_i * a_j / (1 - F) using geometric series identity, since 0 <= F < 1 = p_i * a_i / sum_j(p_j * a_j) using F from above ``` Note that the following constraints hold: ``` 0 <= p_i <= 1, sum_i(p_i) = 1 0 <= a_i <= 1 0 <= t_i <= 1, sum_i(t_i) = 1 ``` A solution for a_i in terms of the other variables is the following: ```a_i = (t_i / p_i) / max_i[t_i / p_i]``` If we try to minimize the amount of data rejected, we get the following: M_max = max_i [ t_i / p_i ] M_min = min_i [ t_i / p_i ] The desired probability of accepting data if it comes from class `i`: a_i = (t_i/p_i - m) / (M_max - m) The desired probability of pulling a data element from the original dataset, rather than the filtered one: m = M_min Args: initial_probs: A Tensor of the initial probability distribution, given or estimated. target_probs: A Tensor of the corresponding classes. Returns: (A 1D Tensor with the per-class acceptance probabilities, the desired probability of pull from the original distribution.) )rr#Z reduce_maxr)rrZratio_lZ max_ratioZ min_ratiomZa_ir>r>r?rs A   rcs2eZdZdZd fdd ZddZddZZS) rz>A dataset that stops iteration when `predicate` returns false.Ncs||_tj|||jd}|jtgtj sDt d|jd||_ ||_ t j|jjf|j jj|j jd|j}tt|||dS)zSee `take_while()` for details.)rz]Invalid `predicate`. `predicate` must return a `tf.bool` scalar tensor but its return type isrI)Zother_argumentsryN)r)rrrZr[rrrrrqr; _predicaterrZtake_while_datasetrZrrrrzrrY)rVrXryr=rrW)rr>r?rY@s  z_TakeWhileDataset.__init__cCs|jgS)N)r)rVr>r>r?rVsz_TakeWhileDataset._functionscCsdS)NzDataset.take_while()r>)rVr>r>r?rZYsz&_TakeWhileDataset._transformation_name)N)rrrrrYrrZrr>r>)rr?r=srcs"eZdZdZdfdd ZZS)rz8A `Dataset` contains the unique elements from its input.Ncsr||_x:tt|D](}|tjtjtjfkrtd|dqW||_ t j |jj f|j }tt|||dS)zSee `unique()` for details.z!`unique()` does not support type z=, only `tf.int32`, `tf.int64`, and `tf.string` are supported.N)r)r rrrrrrorSrrZunique_datasetrZrrzrrY)rVrXr=tyrW)rr>r?rY`sz_UniqueDataset.__init__)N)rrrrrYrr>r>)rr?r]srcs2eZdZdZd fdd ZddZdd ZZS) rzBA dataset that allows saving and re-use of already processed data.NFc s|dkrdd}||_||_||_tj||dtt|j|d|_tj||d||d|_ |j j t gtjs|j j t gtjstd|j j d||_tj|j||jjj|j jjf||jj|j jd |j} tt||| dS) NcSs|jddttdS)NcSs|S)Nr>)rr>r>r?r~rz=_SnapshotDataset.__init__....)rtrb)rvrrr5)r"r>r>r?r}sz+_SnapshotDataset.__init__..z .reader_func)rrz .shard_func)rrz_Invalid `shard_func`. `shard_func` must return `tf.int64` scalar tensor but its return type is rI)r[r^r\)r)_path _compressionrrrZrr _reader_func _shard_funcr[rrrrrrrSrrZsnapshot_dataset_v2rZrrrrzrrY) rVrXrZr\r[r^Zpending_snapshot_expiry_secondsrr=rW)rr>r?rYrs>         z_SnapshotDataset.__init__cCs |j|jgS)N)rr)rVr>r>r?rsz_SnapshotDataset._functionscCsdS)NzDataset.snapshot()r>)rVr>r>r?rZsz%_SnapshotDataset._transformation_name)NNNFN)rrrrrYrrZrr>r>)rr?ros,rcs>eZdZdZd fdd ZddZeddZd d ZZ S) rz1A dataset that scans a function across its input.Ncs||_t||_t|j|_d}x|rtj|||j|j fdd}t |j t j rht|j dksztd|jd|j\}|_|j\}} tdd|j} xBtt|t| D](\} } t| | std | d |dqW|j \} }td d|j}xDtt| t|D]*\}}||krtd |d | dqW|j\}}td d|j}t||| |_t|}t|}ddt||D}d}xHt||D]:\}}|jdk r|jdks||krd}PqW|r(t|t||| |_q(W||_|jj t!"||_#|dk rnt$j%|jj&t'|j|j|jjj(f|jjd|d|j)}n8t$j%|jj&t'|j|j|jjj(f|jjdd|j)}t*t+|,||dS)zSee `scan()` for details.TF)rrrzzInvalid `scan_func`. `scan_func` should return a pair consisting of new state and the output value but its return type is rIcSs|S)N)r)rr>r>r?rrz'_ScanDataset.__init__..zbInvalid `scan_func`. The element classes for the new state must match the initial state. Expected z, got cSs|S)N)r)rr>r>r?rrz`Invalid `scan_func`. The element types for the new state must match the initial state. Expected cSs|S)N)r)rr>r>r?rrcSsg|]\}}||qSr>)r)rdrrr>r>r?rhsz)_ScanDataset.__init__..N)rrjuse_default_device)rrj)-r)r rZ_initial_staterZ_state_structurerrrZrrArr.SequencerrSr[rZ_output_classesr rrrr>rrr,rrr _scan_funcrrrrKrrZ scan_datasetrZrrrrzrrY)rVrXrrrr=rrZnew_state_classesrZold_state_classesrZold_state_classZnew_state_typesrZold_state_typesrZold_state_typeZnew_state_shapesrZold_state_shapesrrrrrrW)rr>r?rYs                     z_ScanDataset.__init__cCs|jgS)N)r)rVr>r>r?r#sz_ScanDataset._functionscCs|jS)N)r,)rVr>r>r?r&sz_ScanDataset.element_speccCsdS)NzDataset.scan()r>)rVr>r>r?rZ*sz!_ScanDataset._transformation_name)NN) rrrrrYrrrrZrr>r>)rr?rs n rcs6eZdZdZd fdd ZddZeddZZS) rzDA substitute for `Dataset.interleave()` on a fixed list of datasets.Fc s||_t||_||_|jdj}xt|jddD]v\}}dd}yt|||j}Wq6tt fk r}z.td|djd|dd|jd|Wdd}~XYq6Xq6W||_ t j |jj d d |jDfd |ji|j} tt|| dS) NrrcSs.||g}|dkr*td|d|d|S)NzNo common supertype of z and rI)r:rS)r4r5r^r>r>r?r_8s z=_DirectedInterleaveDataset.__init__..common_supertypez[Invalid `datasets`. `datasets` must have compatible element specs. Dataset 0 element_spec=z . Dataset z element_spec=rIcSsg|] }|jqSr>)rZ)rd data_inputr>r>r?rhMsz7_DirectedInterleaveDataset.__init__..r)_selector_inputr  _data_inputsZ_stop_on_empty_datasetrrqr rrSr;r,rZdirected_interleave_datasetrZrrzrrY) rVrZ data_inputsrrrerr_rrW)rr>r?rY1s&   & z#_DirectedInterleaveDataset.__init__cCs|jg|jS)N)rr)rVr>r>r?rPSsz"_DirectedInterleaveDataset._inputscCs|jS)N)r,)rVr>r>r?rVsz'_DirectedInterleaveDataset.element_spec)F) rrrrrYrPrrrr>r>)rr?r.s"rcCsttj|j|f|j|jS)N)r+rZrewrite_datasetrZrr)rZrewriter>r>r?rH[s rHcCsPdd}|g}t}g}g}x*|rF|||\}}||||qW||fS)zDCollects resource inputs for the given ops (and its variant inputs).cSsVg}g}|}||kr ||fS||t|\}}|dd|jD||fS)aZProcesses the next element of the op queue. Args: op_queue: Queue of Dataset operations to process. seen_ops: Already processed set of Operations. Returns: A 2-tuple containing sets of resource handles. The first tuple entry contains read-only handles and the second entry contains read-write handles. css |]}|jtjkr|jVqdS)N)rrrr)rdrr>r>r?r~sz=_collect_resource_inputs.._process..)rr: acd_utilsZget_read_write_resource_inputsrr)op_queueseen_opsreadswritesrr>r>r?_processfs  z*_collect_resource_inputs.._process)setr)rrrrZ all_readsZ all_writesrrr>r>r?_collect_resource_inputscs rc Csd}|jdkrbt|\}}x"|D]}||kr d}||q Wx"|D]}||krDd}||qDW|jdkr|jd}dd|D}t|dkrt|d\}}x"|D]}||krd}||qWx"|D]}||krd}||qW|S) zCUpdates resource inputs for tf.data ops with indirect dependencies.F)ZDatasetToSingleElementZDatasetToTFRecordr3T)ZIteratorGetNextZIteratorGetNextSyncZIteratorGetNextAsOptionalrcSsg|]}|jdkr|qS)Z MakeIterator)rD)rdrr>r>r?rhsz&_resource_resolver..r)rDrr:rZ consumersr) rZresource_readsZresource_writesupdatedrrr rZmake_iterator_opsr>r>r?_resource_resolvers2         rFz#data.experimental.enable_debug_modecCstrtdntddS)aEnables debug mode for tf.data. Example usage with pdb module: ``` import tensorflow as tf import pdb tf.data.experimental.enable_debug_mode() def func(x): # Python 3.7 and older requires `pdb.Pdb(nosigint=True).set_trace()` pdb.set_trace() x = x + 1 return x dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3]) dataset = dataset.map(func) for item in dataset: print(item) ``` The effect of debug mode is two-fold: 1) Any transformations that would introduce asynchrony, parallelism, or non-determinism to the input pipeline execution will be forced to execute synchronously, sequentially, and deterministically. 2) Any user-defined functions passed into tf.data transformations such as `map` will be wrapped in `tf.py_function` so that their body is executed "eagerly" as a Python function as opposed to a traced TensorFlow graph, which is the default behavior. Note that even when debug mode is enabled, the user-defined function is still traced to infer the shape and type of its outputs; as a consequence, any `print` statements or breakpoints will be triggered once during the tracing before the actual execution of the input pipeline. NOTE: As the debug mode setting affects the construction of the tf.data input pipeline, it should be enabled before any tf.data definitions. Raises: ValueError: When invoked from graph mode. Tz5`enable_debug_mode() is only supported in eager mode.N)r rtoggle_debug_moder;r>r>r>r?enable_debug_modes- rcCs|adS)N)r) debug_moder>r>r?rsr)N)N)rrN)rrrrrrrrprZtensorflow.core.frameworkrrrZtensorflow.pythonrrrrrMrZtensorflow.python.data.utilr r r r Ztensorflow.python.eagerr Ztensorflow.python.frameworkrrrrrrrrrrrrrrrrZtensorflow.python.opsrrrrrrr r!r"r#r$r%r&Ztensorflow.python.ops.raggedr'Ztensorflow.python.trackabler(r)rwr*Z resource_libZtensorflow.python.typesr+Ztensorflow.python.utilr,r-r7Ztensorflow.python.util.compatr.Z tensorflow.python.util.tf_exportr/r LazyLoaderglobalsr0r1r2ZNotDifferentiabler5Zexport_constantrr8r9ZCOMPRESSION_GZIPZCOMPRESSION_SNAPPYZDATASET_SPEC_FILENAMEr@rFIterableZ TrackableZCompositeTensorABCMetarGrQrrrr rrr&rrerr'r(r*r+r-r0r1ZBatchableTypeSpecrrZCapturableResourcer|rrrr!r#rBrrMrJrPrRrTr`rar{r~rrrfrkrlrorrrsr-r}rrrrrrrrrrrrrrrrrrHrZregister_acd_resource_resolverrrrrr>r>r>r?s                                                    2 !  -)     *E")-('81R(4 ,F+! S 7 M >-*(3