AVhQ dZddlmZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z dd l m Z dd ldd lmZdd lmZd,dZ d-dZedddgd.dZedddgd.dZedgGddZej0dej0dej0dej0dej0dej0dej0ded gGd!d eZej0d ed"gGd#d"eZej0d"ed$gGd%d$eZej0d$ed&gGd'd&eZej0d&ed(gGd)d(eZej0d(ed*gGd+d*eZej0d*y )/zjInputs and Readers. See the [Inputs and Readers](https://tensorflow.org/api_guides/python/io_ops) guide. )context)dtypes)ops)tensor) python_io)gen_data_flow_ops) gen_io_ops)gen_parsing_ops)*) deprecation) tf_exportNcl|tj||||Stj|||||S)a$Save a list of tensors to a file with given names. Example usage without slice info: Save("/foo/bar", ["w", "b"], [w, b]) Example usage with slices: Save("/foo/bar", ["w", "w"], [slice0, slice1], tensor_slices=["4 10 0,2:-", "4 10 2,2:-"]) Args: filename: the file name of the sstable. tensor_names: a list of strings. tensors: the list of tensors to be saved. tensor_slices: Optional list of strings to specify the shape and slices of a larger virtual tensor that each tensor is a part of. If not specified each tensor is saved as a full slice. name: string. Optional name for the op. Requires: The length of tensors should match the size of tensor_names and of tensor_slices. Returns: An Operation that saves the tensors. name)r save save_slices)filename tensor_namestensors tensor_slicesrs L/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/io_ops.py_saver(s=4 ??8\7 FF  ! !(L-") 66cvtj|j}tj||||||S)aDRestore a tensor slice from a set of files with a given pattern. Example usage: RestoreSlice("/foo/bar-?????-of-?????", "w", "10 10 0,2:-", DT_FLOAT) Args: file_pattern: the file pattern used to match a set of checkpoint files. tensor_name: the name of the tensor to restore. shape_and_slice: the shape-and-slice spec of the slice. tensor_type: the type of the tensor to restore. name: string. Optional name for the op. preferred_shard: Int. Optional shard to open first in the checkpoint file. Returns: A tensor of type "tensor_type". r)ras_dtype base_dtyper restore_slice) file_pattern tensor_nameshape_and_slice tensor_typerpreferred_shard base_types r_restore_slicer$Is9$ook*55)  ! !K)D ""rz io.read_file read_file)v1c.tj||S)aReads the contents of file. This operation returns a tensor with the entire contents of the input filename. It does not do any parsing, it just returns the contents as they are. Usually, this is the first step in the input pipeline. Example: >>> with open("/tmp/file.txt", "w") as f: ... f.write("asdf") ... 4 >>> tf.io.read_file("/tmp/file.txt") Example of using the op in a function to read an image, decode it and reshape the tensor containing the pixel data: >>> @tf.function ... def load_image(filename): ... raw = tf.io.read_file(filename) ... image = tf.image.decode_png(raw, channels=3) ... # the `print` executes during tracing. ... print("Initial shape: ", image.shape) ... image.set_shape([28, 28, 3]) ... print("Final shape: ", image.shape) ... return image Args: filename: string. filename to read from. name: string. Optional name for the op. Returns: A tensor of dtype "string", with the file contents. )r r%)rrs rr%r%asJ   h --rzio.serialize_tensorserialize_tensorc.tj||S)aTransforms a Tensor into a serialized TensorProto proto. This operation transforms data in a `tf.Tensor` into a `tf.Tensor` of type `tf.string` containing the data in a binary string in little-endian format. This operation can transform scalar data and linear arrays, but it is most useful in converting multidimensional arrays into a format accepted by binary storage formats such as a `TFRecord` or `tf.train.Example`. See also: - `tf.io.parse_tensor`: inverse operation of `tf.io.serialize_tensor` that transforms a scalar string containing a serialized Tensor in little-endian format into a Tensor of a specified type. - `tf.ensure_shape`: `parse_tensor` cannot statically determine the shape of the parsed tensor. Use `tf.ensure_shape` to set the static shape when running under a `tf.function` - `.SerializeToString`, serializes a proto to a binary-string Example of serializing scalar data: >>> t = tf.constant(1) >>> tf.io.serialize_tensor(t) Example of storing non-scalar data into a `tf.train.Example`: >>> t1 = [[1, 2]] >>> t2 = [[7, 8]] >>> nonscalar = tf.concat([t1, t2], 0) >>> nonscalar Serialize the data using `tf.io.serialize_tensor`. >>> serialized_nonscalar = tf.io.serialize_tensor(nonscalar) >>> serialized_nonscalar Store the data in a `tf.train.Feature`. >>> feature_of_bytes = tf.train.Feature( ... bytes_list=tf.train.BytesList(value=[serialized_nonscalar.numpy()])) >>> feature_of_bytes bytes_list { value: "\010...\000" } Put the `tf.train.Feature` message into a `tf.train.Example`. >>> features_for_example = { ... 'feature0': feature_of_bytes ... } >>> example_proto = tf.train.Example( ... features=tf.train.Features(feature=features_for_example)) >>> example_proto features { feature { key: "feature0" value { bytes_list { value: "\010...\000" } } } } Args: tensor: A `tf.Tensor`. name: string. Optional name for the op. Returns: A Tensor of dtype string. )r r()rrs rr(r(sZ  ) )&$ 77r ReaderBasecreZdZdZd dZedZddZ ddZddZ ddZ dd Z dd Z ed Z dd Zy)r*aBase class for different Reader types, that produce a record every step. Conceptually, Readers convert string 'work units' into records (key, value pairs). Typically the 'work units' are filenames and the records are extracted from the contents of those files. We want a single record produced per step, but a work unit can correspond to many records. Therefore we introduce some decoupling using a queue. The queue contains the work units and the Reader dequeues from the queue when it is asked to produce a record (via Read()) but it has finished the last work unit. @compatibility(eager) Readers are not compatible with eager execution. Instead, please use `tf.data` to get data into your model. @end_compatibility c^tjr td||_||_y)aCreates a new ReaderBase. Args: reader_ref: The operation that implements the reader. supports_serialize: True if the reader implementation can serialize its state. Raises: RuntimeError: If eager execution is enabled. zsReaders are not supported when eager execution is enabled. Instead, please use tf.data to get data into your model.N)rexecuting_eagerly RuntimeError _reader_ref_supports_serialize)self reader_refsupports_serializes r__init__zReaderBase.__init__s7  "  E FF"D1Drc|jS)zOp that implements the reader.)r/r1s rr2zReaderBase.reader_refs   rNcTt|tjr|}n |j}|jj t jk(r"tj|j||Stj|}tj|j||S)aReturns the next record (key, value) pair produced by a reader. Will dequeue a work unit from queue if necessary (e.g. when the Reader needs to start reading from a new file since it has finished with the previous file). Args: queue: A Queue or a mutable string Tensor representing a handle to a Queue, with string work items. name: A name for the operation (optional). Returns: A tuple of Tensors (key, value). key: A string scalar Tensor. value: A string scalar Tensor. r) isinstance tensor_libTensor queue_refr/dtyperresourcer reader_read_v2r fake_queue reader_read)r1queuerr; old_queue_ops rreadzReaderBase.reads"%**+i//i 0  & &t'7'7 NN'11)rsv" ,.+<.3,1/.66D:<"0 >~{;<$.=$.N 46HIKK8KK8\ |nIBIBIBXl#&'0134,-*+m$  !"GjG#G6'(  !-Z-"-:&' ()*'6j'6+'6T/0  !-Z-"-<&' |n)))4l#  !FZF"F6&'r