BVh: dZddlmZmZddlZddlmZddlm Z ddl m Z ddl m Z ddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z!ddl"m#Z#ddl$m%Z&ddl$m'Z'ddl(m)Z)ddl(m*Z*ddl(m+Z+ddl,m-Z-ej\ddZ/d Z0d@d!Z1dd"d#Z2Gd$d%e3Z4e-d&d'd&g(Gd)d&e'jje&jlZ7e-d*g(d+Z8e-d,g(d-Z9d.e:d/e:fd0Z;d1Z<Gd2d3ejzZ>e-d4ej~d5Gd6d4e>eje je'jZBe jeBe jeBGd7d8ZEe#jeEej~d9Gd:d;eBe jZGGd<d=ZHe#jeHe jeGeje7d>ejejd?y)AzTensor and TensorSpec classes.)OptionalTypeN)attr_value_pb2) trace_type) struct_pb2)tf2)context) monitoring)record) common_shapes)dtypes)errors) op_callbacks)stack)tensor_conversion_registry) tensor_shape) tensor_util) type_spec)type_spec_registry)handle_data_util) tf_logging)nested_structure_coder)core)internal)compat) deprecation)object_identity) tf_exportz&/tensorflow/api/enable_tensor_equalityz/Whether ops.enable_tensor_equality() is called.c|tjvr td|dtjdt|||y)aNOverrides (string) operator on Tensors to call func. Args: clazz_object: the class to override for; either Tensor or SparseTensor. operator: the string name of the operator to override. func: the function that replaces the overridden operator. Raises: ValueError: If operator is not allowed to be overwritten. z Overriding z& is disallowed. Allowed operators are .N)TensorOVERLOADABLE_OPERATORS ValueErrorsetattr) clazz_objectoperatorfuncs R/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/framework/tensor.py_override_helperr)6sLV222 {8*-..4.K.K-LAO PP ,$'c|:tj}| td|j|ur$td|j|ur td|j ||S)aUses the default session to evaluate one or more tensors. Args: tensors: A single Tensor, or a list of Tensor objects. feed_dict: A dictionary that maps Tensor objects (or tensor names) to lists, numpy ndarrays, TensorProtos, or strings. graph: The graph in which the tensors are defined. session: (Optional) A different session to use to evaluate "tensors". Returns: Either a single numpy ndarray if "tensors" is a single tensor; or a list of numpy ndarrays that each correspond to the respective element in "tensors". Raises: ValueError: If no default session is available; the default session does not have "graph" as its graph; or if "session" is specified, and it does not have "graph" as its graph. zCannot evaluate tensor using `eval()`: No default session is registered. Use `with sess.as_default()` or pass an explicit session to `eval(session=sess)`zCannot use the default session to evaluate tensor: the tensor's graph is different from the session's graph. Pass an explicit session to `eval(session=sess)`.zjCannot use the given session to evaluate tensor: the tensor's graph is different from the session's graph.)rget_default_sessionr#graphrun)tensors feed_dictr-sessions r(_eval_using_default_sessionr2Gs( _'')G . //}}E! / 00 }}E!   !! Wi ((r*namec||S|d|S)N: )msgr4s r(_add_error_prefixr9os 2TF"SE"22r*c.eZdZdZgdZdZdZdZeZy)_TensorIteratorzDIterates over the leading dim of a Tensor. Performs no error checks._tensor_index_limitc.||_d|_||_y)Nrr<)selftensordim0s r(__init__z_TensorIterator.__init__xsDLDKDKr*c|SNr7rAs r(__iter__z_TensorIterator.__iter__}s Kr*c|j|jk(rt|j|j}|xjdz c_|S)N)r>r? StopIterationr=)rAresults r(__next__z_TensorIterator.__next__s= {{dkk!  \\$++ &FKK1K Mr*N) __name__ __module__ __qualname____doc__ __slots__rDrHrMnextr7r*r(r;r;ss L-)  $r*r;r!zexperimental.numpy.ndarray)v1ceZdZdZhdZej ZdZe dZ e dZ e de jfdZe dZd Zd Zd Zd Zd ZdZdZdZde jfdZdZdZdZdZdZdZd&dZdZ e!dZ"dZ#dZ$d'dZ%e&jNddd Z(d!Z)d"Z* d'd#e+e,jZd$e+e.ddfd%Z/y)(r!aA `tf.Tensor` represents a multidimensional array of elements. All elements are of a single known data type. When writing a TensorFlow program, the main object that is manipulated and passed around is the `tf.Tensor`. A `tf.Tensor` has the following properties: * a single data type (float32, int32, or string, for example) * a shape TensorFlow supports eager execution and graph execution. In eager execution, operations are evaluated immediately. In graph execution, a computational graph is constructed for later evaluation. TensorFlow defaults to eager execution. In the example below, the matrix multiplication results are calculated immediately. >>> # Compute some values using a Tensor >>> c = tf.constant([[1.0, 2.0], [3.0, 4.0]]) >>> d = tf.constant([[1.0, 1.0], [0.0, 1.0]]) >>> e = tf.matmul(c, d) >>> print(e) tf.Tensor( [[1. 3.] [3. 7.]], shape=(2, 2), dtype=float32) Note that during eager execution, you may discover your `Tensors` are actually of type `EagerTensor`. This is an internal detail, but it does give you access to a useful function, `numpy`: >>> type(e) >>> print(e.numpy()) [[1. 3.] [3. 7.]] In TensorFlow, `tf.function`s are a common way to define graph execution. A Tensor's shape (that is, the rank of the Tensor and the size of each dimension) may not always be fully known. In `tf.function` definitions, the shape may only be partially known. Most operations produce tensors of fully-known shapes if the shapes of their inputs are also fully known, but in some cases it's only possible to find the shape of a tensor at execution time. A number of specialized tensors are available: see `tf.Variable`, `tf.constant`, `tf.placeholder`, `tf.sparse.SparseTensor`, and `tf.RaggedTensor`. Caution: when constructing a tensor from a numpy array or pandas dataframe the underlying buffer may be re-used: ```python a = np.array([1, 2, 3]) b = tf.constant(a) a[0] = 4 print(b) # tf.Tensor([4 2 3], shape=(3,), dtype=int64) ``` Note: this is an implementation detail that is subject to change and users should not rely on this behaviour. For more on Tensors, see the [guide](https://tensorflow.org/guide/tensor). >"__eq____ge____gt____le____lt____ne____or____abs____add____and____div____mod____mul____neg____pow____ror____sub____xor____radd____rand____rdiv____rmod____rmul____rpow____rsub____rxor__ __invert__ __matmul__ __getitem__ __rmatmul__ __truediv__ __floordiv__ __rtruediv__ __rfloordiv__c||dvr'tt|jd|ddz|j|y)N> Tclipdatasizeravelastypetolistreshape transposez object has no attribute 'z'. z If you are looking for numpy-related methods, please run the following: tf.experimental.numpy.experimental_enable_numpy_behavior() )AttributeErrortyperN__getattribute__)rAr4s r( __getattr__zTensor.__getattr__sU ""  $Z !!;D6 EI     $r*c|jS)z'The `DType` of elements in this tensor._dtyperGs r(dtypez Tensor.dtype ;;r*c|jSrF_namerGs r(r4z Tensor.name s ::r*returnc|jP|j\}}|r%tj|_|jStj||_|jS)aCReturns a `tf.TensorShape` that represents the shape of this tensor. >>> t = tf.constant([1,2,3,4,5]) >>> t.shape TensorShape([5]) `tf.Tensor.shape` is equivalent to `tf.Tensor.get_shape()`. In a `tf.function` or when building a model using `tf.keras.Input`, they return the build-time shape of the tensor, which may be partially unknown. A `tf.TensorShape` is not a tensor. Use `tf.shape(t)` to get a tensor containing the shape, calculated at runtime. See `tf.Tensor.get_shape()`, and `tf.TensorShape` for details and examples. ) _shape_val_shaper unknown_shape TensorShape)rAdimsrs r(shapez Tensor.shapesY&  KKdM &446 ??'2248 ??r*c.|jjSrF)rrankrGs r(ndimz Tensor.ndim*s ::??r*c2tj|d)Na is not allowed. You can attempt the following resolutions to the problem: If you are running in Graph mode, use Eager execution mode or decorate this function with @tf.function. If you are using AutoGraph, you can try decorating this function with @tf.function. If that does not work, then you may be using an unsupported feature or your source code may not be visible to AutoGraph. See https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/autograph/g3doc/reference/limitations.md#access-to-source-code for more information.)rOperatorNotAllowedInGraphError)rAtasks r( _disallowzTensor._disallow.s$  / / & ! ! " "r*c&|jdy)Nz/Using a symbolic `tf.Tensor` as a Python `bool`rrGs r(_disallow_bool_castingzTensor._disallow_bool_casting;sNNDEr*c&|jdy)Nz%Iterating over a symbolic `tf.Tensor`rrGs r(_disallow_iterationzTensor._disallow_iteration>sNN:;r*ctjs|j|j}t ||SrF)r executing_eagerlyr_get_first_dimr;)rA first_dims r(rHzTensor.__iter__As5  $ $ &  ##%I 4 ++r*c|j}| td|s td|d td|dS)Nz0Cannot iterate over a tensor with unknown shape.z$Cannot iterate over a scalar tensor.rz:Cannot iterate over a tensor with unknown first dimension.) _shape_tuple TypeErrorrArs r(rzTensor._get_first_dimHsU    E } H II  < == Qx  F HH 8Or*c|jj.|jjDcgc]}|jc}Sycc}wrF)rndimsrvalue)rAdims r(_shape_as_listzTensor._shape_as_listSs7 zz##'::?? 3Ccii 33 4sAc>|j}|yt|SrF)rtuplers r(rzTensor._shape_tupleYs"    !E }  <r*c@tjd|g|gddy)zAConnect this graph tensor with capture for gradients calculation.captured_valuec|gSrFr7xs r(z%Tensor._record_tape..dsQCr*c|gSrFr7rs r(rz%Tensor._record_tape..esA3r*)backward_functionforward_functionN)r record_operation)rAcaptures r( _record_tapezTensor._record_tape_s"   '& (r*c|jS)a Returns a `tf.TensorShape` that represents the shape of this tensor. In eager execution the shape is always fully-known. >>> a = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) >>> print(a.shape) (2, 3) `tf.Tensor.get_shape()` is equivalent to `tf.Tensor.shape`. When executing in a `tf.function` or building a model using `tf.keras.Input`, `Tensor.shape` may return a partial shape (including `None` for unknown dimensions). See `tf.TensorShape` for more details. >>> inputs = tf.keras.Input(shape = [10]) >>> # Unknown batch size >>> print(inputs.shape) (None, 10) The shape is computed using shape inference functions that are registered for each `tf.Operation`. The returned `tf.TensorShape` is determined at *build* time, without executing the underlying kernel. It is not a `tf.Tensor`. If you need a shape *tensor*, either convert the `tf.TensorShape` to a `tf.constant`, or use the `tf.shape(tensor)` function, which returns the tensor's shape at *execution* time. This is useful for debugging and providing early errors. For example, when tracing a `tf.function`, no ops are being executed, shapes may be unknown (See the [Concrete Functions Guide](https://www.tensorflow.org/guide/concrete_function) for details). >>> @tf.function ... def my_matmul(a, b): ... result = a@b ... # the `print` executes during tracing. ... print("Result shape: ", result.shape) ... return result The shape inference functions propagate shapes to the extent possible: >>> f = my_matmul.get_concrete_function( ... tf.TensorSpec([None,3]), ... tf.TensorSpec([3,5])) Result shape: (None, 5) Tracing may fail if a shape missmatch can be detected: >>> cf = my_matmul.get_concrete_function( ... tf.TensorSpec([None,3]), ... tf.TensorSpec([4,5])) Traceback (most recent call last): ... ValueError: Dimensions must be equal, but are 3 and 4 for 'matmul' (op: 'MatMul') with input shapes: [?,3], [4,5]. In some cases, the inferred shape may have unknown dimensions. If the caller has additional information about the values of these dimensions, `tf.ensure_shape` or `Tensor.set_shape()` can be used to augment the inferred shape. >>> @tf.function ... def my_fun(a): ... a = tf.ensure_shape(a, [5, 5]) ... # the `print` executes during tracing. ... print("Result shape: ", a.shape) ... return a >>> cf = my_fun.get_concrete_function( ... tf.TensorSpec([None, None])) Result shape: (5, 5) Returns: A `tf.TensorShape` representing the shape of this tensor. rrGs r( get_shapezTensor.get_shapegs^ ::r*cNd|_t|tjstj|}g}|jd}nLd}|jD];}|j |j d!|j |j =|j||y)aUpdates the shape of this tensor. Note: It is recommended to use `tf.ensure_shape` instead of `Tensor.set_shape`, because `tf.ensure_shape` provides better checking for programming errors and can create guarantees for compiler optimization. With eager execution this operates as a shape assertion. Here the shapes match: >>> t = tf.constant([[1,2,3]]) >>> t.set_shape([1, 3]) Passing a `None` in the new shape allows any value for that axis: >>> t.set_shape([1,None]) An error is raised if an incompatible shape is passed. >>> t.set_shape([1,5]) Traceback (most recent call last): ... ValueError: Tensor's shape (1, 3) is not compatible with supplied shape [1, 5] When executing in a `tf.function`, or building a model using `tf.keras.Input`, `Tensor.set_shape` will *merge* the given `shape` with the current shape of this tensor, and set the tensor's shape to the merged value (see `tf.TensorShape.merge_with` for details): >>> t = tf.keras.Input(shape=[None, None, 3]) >>> print(t.shape) (None, None, None, 3) Dimensions set to `None` are not updated: >>> t.set_shape([None, 224, 224, None]) >>> print(t.shape) (None, 224, 224, 3) The main use case for this is to provide additional shape information that cannot be inferred from the graph alone. For example if you know all the images in a dataset have shape [28,28,3] you can set it with `tf.set_shape`: >>> @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 Trace the function, see the [Concrete Functions Guide](https://www.tensorflow.org/guide/concrete_function) for details. >>> cf = load_image.get_concrete_function( ... tf.TensorSpec([], dtype=tf.string)) Initial shape: (None, None, 3) Final shape: (28, 28, 3) Similarly the `tf.io.parse_tensor` function could return a tensor with any shape, even the `tf.rank` is unknown. If you know that all your serialized tensors will be 2d, set it with `set_shape`: >>> @tf.function ... def my_parse(string_tensor): ... result = tf.io.parse_tensor(string_tensor, out_type=tf.float32) ... # the `print` executes during tracing. ... print("Initial shape: ", result.shape) ... result.set_shape([None, None]) ... print("Final shape: ", result.shape) ... return result Trace the function >>> concrete_parse = my_parse.get_concrete_function( ... tf.TensorSpec([], dtype=tf.string)) Initial shape: Final shape: (None, None) Make sure it works: >>> t = tf.ones([5,3], dtype=tf.float32) >>> serialized = tf.io.serialize_tensor(t) >>> print(serialized.dtype) >>> print(serialized.shape) () >>> t2 = concrete_parse(serialized) >>> print(t2.shape) (5, 3) Caution: `set_shape` ensures that the applied shape is compatible with the existing shape, but it does not check at runtime. Setting incorrect shapes can result in inconsistencies between the statically-known graph and the runtime value of tensors. For runtime validation of the shape, use `tf.ensure_shape` instead. It also modifies the `shape` of the tensor. >>> # Serialize a rank-3 tensor >>> t = tf.ones([5,5,5], dtype=tf.float32) >>> serialized = tf.io.serialize_tensor(t) >>> # The function still runs, even though it `set_shape([None,None])` >>> t2 = concrete_parse(serialized) >>> print(t2.shape) (5, 5, 5) Args: shape: A `TensorShape` representing the shape of this tensor, a `TensorShapeProto`, a list, a tuple, or None. Raises: ValueError: If `shape` is not compatible with the current shape of this tensor. NTF)r isinstancerrrrappend _set_shape)rArdim_listrrs r( set_shapezTensor.set_shapesrDO e\55 6&&u-eH zzmm%# 99  //"  //#)) $ %  OOHm,r*c|jjsJ|jdk(r|jjSd|jj|jfzS)a+Return a value to use for the NodeDef "input" attribute. The returned string can be used in a NodeDef "input" attribute to indicate that the NodeDef uses this Tensor as input. Raises: ValueError: if this Tensor's Operation does not have a name. Returns: a string. rz%s:%d)_opr4 value_indexrGs r(_as_node_def_inputzTensor._as_node_def_inputBsN 88=== 1 XX]]  t'7'78 88r*cd|jd|jjd|jznd|jrd|jjznd|jrd|jzdSddS)NzTensor(""z , shape=%sz , dtype=%sz , device=%s))r4rrrdevicerGs r(__str__zTensor.__str__Ts "nn.44@    FH I-1[[ (( (b@)- $<  >> ;=<  >>r*crd|jd|jd|jjdS)Nz )r4rrrGs r(__repr__zTensor.__repr__\s+3799dnn>N37;;3C3C EEr*ct|dd}tjr| |jr t dt |S)Nr-z;Tensor is unhashable. Instead, use tensor.ref() as the key.)getattrr! _USE_EQUALITYbuilding_functionrid)rAgs r(__hash__zTensor.__hash__`sBgt$A!)q/B/B > ??Xor*dNc6~td|jd)Nz%Cannot convert a symbolic tf.Tensor (zx) to a numpy array. This error may indicate that you're trying to pass a Tensor to a NumPy call, which is not supported.)NotImplementedErrorr4)rArs r( __array__zTensor.__array__qs'  / {;1 2 33r*c4td|jd)Nz/len is not well defined for a symbolic Tensor (zD). Please call `x.shape` rather than `len(x)` for shape information.)rr4rGs r(__len__zTensor.__len__xs'  {#67 88r*c&tt||yrF)r)r!)r&r's r(_override_operatorzTensor._override_operator~sVXt,r*c$|jy)aDummy method to prevent a tensor from being used as a Python `bool`. This overload raises a `TypeError` when the user inadvertently treats a `Tensor` as a boolean (most commonly in an `if` or `while` statement), in code that was not converted by AutoGraph. For example: ```python if tf.constant(True): # Will raise. # ... if tf.constant(5) < tf.constant(7): # Will raise. # ... ``` Raises: `TypeError`. NrrGs r(__bool__zTensor.__bool__s$ !r*c$|jy)zDummy method to prevent a tensor from being used as a Python `bool`. This is the Python 2.x counterpart to `__bool__()` above. Raises: `TypeError`. NrrGs r( __nonzero__zTensor.__nonzero__s !r*c2t|||j|S)aEvaluates this tensor in a `Session`. Note: If you are not using `compat.v1` libraries, you should not need this, (or `feed_dict` or `Session`). In eager execution (or within `tf.function`) you do not need to call `eval`. Calling this method will execute all preceding operations that produce the inputs needed for the operation that produces this tensor. *N.B.* Before invoking `Tensor.eval()`, its graph must have been launched in a session, and either a default session must be available, or `session` must be specified explicitly. Args: feed_dict: A dictionary that maps `Tensor` objects to feed values. See `tf.Session.run` for a description of the valid feed values. session: (Optional.) The `Session` to be used to evaluate this tensor. If none, the default session will be used. Returns: A numpy array corresponding to the value of this tensor. )r2r-)rAr0r1s r(evalz Tensor.evals0 'tY G LLr*zUse ref() instead.c"|jSrF)refrGs r(experimental_refzTensor.experimental_refs 88:r*c,tj|S)aReturns a hashable reference object to this Tensor. The primary use case for this API is to put tensors in a set/dictionary. We can't put tensors in a set/dictionary as `tensor.__hash__()` is no longer available starting Tensorflow 2.0. The following will raise an exception starting 2.0 >>> x = tf.constant(5) >>> y = tf.constant(10) >>> z = tf.constant(10) >>> tensor_set = {x, y, z} Traceback (most recent call last): ... TypeError: Tensor is unhashable. Instead, use tensor.ref() as the key. >>> tensor_dict = {x: 'five', y: 'ten'} Traceback (most recent call last): ... TypeError: Tensor is unhashable. Instead, use tensor.ref() as the key. Instead, we can use `tensor.ref()`. >>> tensor_set = {x.ref(), y.ref(), z.ref()} >>> x.ref() in tensor_set True >>> tensor_dict = {x.ref(): 'five', y.ref(): 'ten', z.ref(): 'ten'} >>> tensor_dict[y.ref()] 'ten' Also, the reference object provides `.deref()` function that returns the original Tensor. >>> x = tf.constant(5) >>> x.ref().deref() )r ReferencerGs r(rz Tensor.refsN  $ $T **r*cp|jtjk(s|jtjk(rYt j |}|rtj |nd}tj|jj|}n |j}t|j|}|SrF) rr resourcevariantrget_handle_data HandleDataDType _type_enum TensorSpecr)rAsignature_contextshape_inference_handle_data handle_datarspecs r(__tf_tracing_type__zTensor.__tf_tracing_type__s zzV__$ fnn(D$4$D$DT$J!)   7 8 ll4::00+>ejje djj% (D Kr*rr4c |X|j|js=ttd|jd|jjd|||S)Nz"Tensor conversion requested dtype z for Tensor with dtype r6r3)is_compatible_withrr#r9r4)rArr4s r( __tf_tensor__zTensor.__tf_tensor__sd !9!9$**!E  25::,?''+zz&7r$C   Kr*rF)NN)0rNrOrPrQr"renabledrrpropertyrr4rrrrrrrrHrrrrrrrrrr__array_priority__rr staticmethodrrrrr deprecatedrrrrr rstrrr7r*r(r!r!ssCJ%P#++--       \-- 4   "F<,   (O11ObH-T9$>E38 --"("M4;$ 456'+R IM FLL) 8@    r*enable_tensor_equalityctjddtjj ddt _y)a4Compare Tensors with element-wise comparison and thus be unhashable. Comparing tensors with element-wise allows comparisons such as tf.Variable(1.0) == 1.0. Element-wise equality implies that tensors are unhashable. Thus tensors can no longer be directly used in sets or as a key in a dictionary. rJzEnabling tensor equalityTNloggingvlog _tensor_equality_api_usage_gaugeget_cellsetr!rr7r*r(rrs2 ,,q,-"++-11$7&r*disable_tensor_equalityctjddtjj ddt _y)zvCompare Tensors by their id and be hashable. This is a legacy behaviour of TensorFlow and is highly discouraged. rJzDisabling tensor equalityFNrr7r*r(r r s2  ,,q-."++-11%8&r*r4rc|sydj|jDcgc]}|jr|ndc}}|djr|Sd|zScc}w)ahSanitizes Spec names. Matches Graph Node and Python naming conventions. Without sanitization, names that are not legal Python parameter names can be set which makes it challenging to represent callables supporting the named calling capability. Args: name: The name to sanitize. Returns: A string that meets Python parameter conventions. unknownr_rtensor_)joinlowerisalnumisalpha)r4cswappeds r(sanitize_spec_namers^   GG E1!))+Q3.E F' QZ N w  FsAc|std|d|jdr|dd}d|vr|jd\}}|S|S)afExtract the Op name from a Tensor name. The Op name is everything before a colon, if present, not including any ^ prefix denoting a control dependency. Args: tensor_name: the full name of a Tensor in the graph. Returns: The name of the Op of which the given Tensor is an output. Raises: ValueError: if tensor_name is None or empty. z/Tensor name cannot be empty or None. Received: r ^rJN:)r# startswithsplit) tensor_nameop_namers r( get_op_namer!4sd   9+aH JJC ab/KK""3'JGQ N r*ceZdZdZgdZedZejdfdZ edZ edZ edZ d Z d Zd Zd Zd ZdZdZdZdZy) DenseSpecz5Describes a dense object with shape, dtype, and name.rrrc|SrFr7rGs r(rzDenseSpec.Ss4r*Ncztj||_tj||_||_y)aoCreates a TensorSpec. Args: shape: Value convertible to `tf.TensorShape`. The shape of the tensor. dtype: Value convertible to `tf.DType`. The type of the tensor values. name: Optional name for the Tensor. Raises: TypeError: If shape is not convertible to a `tf.TensorShape`, or dtype is not convertible to a `tf.DType`. N)rrrr as_dtyperr)rArrr4s r(rDzDenseSpec.__init__Us-**51DK//%(DKDJr*c|jS)zBReturns the `TensorShape` that represents the shape of the tensor.rrGs r(rzDenseSpec.shapeerr*c|jS)z.Returns the `dtype` of elements in the tensor.rrGs r(rzDenseSpec.dtypejrr*c|jS)z?Returns the (optionally provided) name of the described tensor.rrGs r(r4zDenseSpec.nameos ::r*ct|t|jfxrL|jj |j xr%|j j |jSrF)rr# value_typerrrrr)rA spec_or_values r(rzDenseSpec.is_compatible_withtsW }y$//&B C @ KK * *=+>+> ? @ KK * *=+>+> ?Ar*cdjt|j|jt |j t |j S)Nz{}(shape={}, dtype={}, name={}))formatrrNrreprrr4rGs r(rzDenseSpec.__repr__ys? , 3 3 T TZZdjj)94 ? LLr*cDt|j|jfSrFhashrrrGs r(rzDenseSpec.__hash__} djj) **r*ct|t|uxrO|j|jk(xr4|j|jk(xr|j|jk(SrF)rrrrrAothers r(rVzDenseSpec.__eq__sY J$u+ % F$++*E F KK5<< ' F,0JJ%++,EGr*c||k( SrFr7r7s r(r[zDenseSpec.__ne__su} r*cH|j|j|jfSrFr$rGs r( _serializezDenseSpec._serializes KKdjj 11r*c|jSrFrrGs r(_to_legacy_output_typesz!DenseSpec._to_legacy_output_types ;;r*c|jSrFr)rGs r(_to_legacy_output_shapesz"DenseSpec._to_legacy_output_shapesr>r*c|jSrF)r-rGs r(_to_legacy_output_classesz#DenseSpec._to_legacy_output_classess ??r*)rNrOrPrQrRr_component_specsr float32rDrrr4rrrrVr[r;r=r@rBr7r*r(r#r#Ns=+)/0"(..t       A L+G 2r*r#rz tf.TensorSpeccTeZdZdZgZedeejfdZ edejddfdZ dejfdZ fdZ dZ d Zdd Zd Zd Zd ZdZdZeddZeddZedZdZdZdZddZdZdZedZdZ dZ!ddZ"xZ#S) ramDescribes the type of a tf.Tensor. >>> t = tf.constant([[1,2,3],[4,5,6]]) >>> tf.TensorSpec.from_tensor(t) TensorSpec(shape=(2, 3), dtype=tf.int32, name=None) Contains metadata for describing the nature of `tf.Tensor` objects accepted or returned by some TensorFlow APIs. For example, it can be used to constrain the type of inputs accepted by a tf.function: >>> @tf.function(input_signature=[tf.TensorSpec([1, None])]) ... def constrained_foo(t): ... print("tracing...") ... return t Now the `tf.function` is able to assume that `t` is always of the type `tf.TensorSpec([1, None])` which will avoid retracing as well as enforce the type restriction on inputs. As a result, the following call with tensor of type `tf.TensorSpec([1, 2])` triggers a trace and succeeds: >>> constrained_foo(tf.constant([[1., 2]])).numpy() tracing... array([[1., 2.]], dtype=float32) The following subsequent call with tensor of type `tf.TensorSpec([1, 4])` does not trigger a trace and succeeds: >>> constrained_foo(tf.constant([[1., 2, 3, 4]])).numpy() array([[1., 2., 3., 4.], dtype=float32) But the following call with tensor of type `tf.TensorSpec([2, 2])` fails: >>> constrained_foo(tf.constant([[1., 2], [3, 4]])).numpy() Traceback (most recent call last): ... TypeError: Binding inputs to tf.function `constrained_foo` failed ... rc"tjS)zCReturns the type of proto associated with TensorSpec serialization.)rTensorSpecProtoclss r(experimental_type_protoz"TensorSpec.experimental_type_protos  % %%r*protocttjj|j|j |j r|j SdS)z>u{{Kkk ::UZZ 11,0 11r*ctj|jj|jjj |j S)z:Returns a proto representation of the TensorSpec instance.rM)rrGrexperimental_as_protordatatyper4rGs r(rQz TensorSpec.experimental_as_protosB  % %jj..0jj..099 YY r*c*tt| |S)aaReturns True if spec_or_tensor is compatible with this TensorSpec. Two tensors are considered compatible if they have the same dtype and their shapes are compatible (see `tf.TensorShape.is_compatible_with`). Args: spec_or_tensor: A tf.TensorSpec or a tf.Tensor Returns: True if spec_or_tensor is compatible with self. )superrr)rAspec_or_tensor __class__s r(rzTensorSpec.is_compatible_withs T 5n EEr*ct|tsy|j xs|j|jk(xrL|jj |jxr%|j j |j S)NF)rrr4r is_subtype_ofrr7s r(rXzTensorSpec.is_subtype_ofsg eZ ( YY 1$))uzz1 2 JJ $ $U[[ 1 2 JJ $ $U[[ 1r*c&|jr|S|jxs |j}|j}|jr.|j d5|j ||}dddn|j ||}|Cjjdtjtj||jj}|L|jj r6|jj"r t%j&|j|j(Mjjdtjtj|j(S#1swYxYw)zCGenerates a graph placholder with the given TensorSpec information.Nr3_user_specified_name)s_composite_device) unnest_onlyr4 naming_scope context_graphwith_none_control_dependenciescontrol_dependencies_graph_placeholderop _set_attrr AttrValueras_bytesr _handle_datashape_inferenceis_setshape_and_typerset_handle_datacomposite_device_name)rAplaceholder_contextr4r_ placeholderrs r(placeholder_valuezTensorSpec.placeholder_values`&& k 99 8+88D'55M99  - -d 3H--m$-G HH++M+Ek nn  " "V__T%: ;=**))K  ' ' . .  ' ' 6 6&&{K4O4OP 00<nn   " "V__!77&9 :; ;HHs FFc|jj}|j}tj|j }t |ttfrtj|}tj|j}||d} |jdg|gg||}|j \} t#j$r>+; E ;; $ $TZZ 0  %ekk],tzzl K  7Nr*ct|}|jj}|r tj||j |SrF)rSrrgrrkrh)rAr/rBrs r( from_tensorszTensorSpec.from_tensors@s8 ']F**))K&&v{/J/JK Mr*c|gSrFr7rGs r(flattenzTensorSpec.flattenGs 6Mr*c|jr0t|tr |j|s Jd|d||St|ts t j ||j}t|j|j|j}|j|s?|j|r|j|j|Std|d||S)z>> spec = tf.TensorSpec(shape=[8, 3], dtype=tf.int32, name="OriginalName") >>> tf.TensorSpec.from_spec(spec, "NewName") TensorSpec(shape=(8, 3), dtype=tf.int32, name='NewName') Args: spec: The `TypeSpec` used to create the new `TensorSpec`. name: The name for the new `TensorSpec`. Defaults to `spec.name`. rM)rIrr4s r( from_speczTensorSpec.from_specfs$ tzz4::t'8tyy 99r*cNt|tjr!t|j|j |St|tj r9t|j|j |xs|jjStdt|d)alReturns a `TensorSpec` that describes `tensor`. >>> tf.TensorSpec.from_tensor(tf.constant([1, 2, 3])) TensorSpec(shape=(3,), dtype=tf.int32, name=None) Args: tensor: The `tf.Tensor` that should be described. name: A name for the `TensorSpec`. Defaults to `tensor.op.name`. Returns: A `TensorSpec` that describes `tensor`. z-`tensor` should be a tf.Tensor, but got type r ) r core_tf_typesValuerrrSymbolrcr4r#r)rIrBr4s r( from_tensorzTensorSpec.from_tensorts~&---.  fllD 99 FM00 1  fllD4JFIINN KK  9$v,q I KKr*ctS)zBThe Python type for values that are compatible with this TypeSpec.)r!rGs r(r-zTensorSpec.value_types  Mr*c>t|tjsJ|SrF)rrr!rs r(_to_componentszTensorSpec._to_componentss e]11 22 2 Lr*c|SrFr7)rA componentss r(_from_componentszTensorSpec._from_componentss r*cht|dk(sJ|dj|j|dS)NrJr)lenrr)rA tensor_lists r(_from_compatible_tensor_listz'TensorSpec._from_compatible_tensor_lists7 { q  NT[[) q>r*c|r=|jj|jjdk(r t d|j |S)Nr3Unbatching a tensor is only supported for rank >= 1)r merge_withrrr#r)rArbatcheds r(_to_batchable_tensor_listz$TensorSpec._to_batchable_tensor_listsB4;;))%++6<<A L MM   u %%r*cttj|gj|j|j SrF)rrr concatenaterr)rA batch_sizes r(_batchzTensorSpec._batchs5   *.::4;;G  r*c|jjdk(r tdt|jdd|jS)NrrrJ)rrr#rrrGs r(_unbatchzTensorSpec._unbatchs; {{A L MM dkk!"ot{{ 33r*c|gSrFr7rGs r(_flat_tensor_specszTensorSpec._flat_tensor_specss 6Mr*c&|j|gSrF)rrs r(_to_tensor_listzTensorSpec._to_tensor_lists    & ''r*c$|j|SrF)rrs r(_to_batched_tensor_listz"TensorSpec._to_batched_tensor_lists    &&r*c^|j|St|j|jS)z8Returns a version of `TensorSpec` with the name removed.)r4rrrrGs r(_without_tensor_namesz TensorSpec._without_tensor_namess& yy k  DJJ //r*rF)F)rr)$rNrOrPrQrR classmethodrrrGrJrNrQrrXrorbrrrrrrrrr-rrrrrrrrrr __classcell__rVs@r(rrs&P)&d:+E+E&F&&1,,11=11Z%?%? F'R>* : :KK,   &  4   (' 0r*c(eZdZdZdZdZdZdZy)_TensorSpecCodeczCodec for `TensorSpec`.cHt|txrt|t SrF)rrBoundedTensorSpecrApyobjs r( can_encodez_TensorSpecCodec.can_encodes$ uj ) 55"34 46r*c tj}|jjtj||j j ||jj|j|S)NrM) rStructuredValuetensor_spec_valueCopyFromrGrtensor_shape_valuertensor_dtype_valuer4)rAr encode_fnencoded_tensor_specs r( do_encodez_TensorSpecCodec.do_encodesn$446))22""-334GG-334GG"'' )* r*c$|jdS)NrHasFieldrs r( can_decodez_TensorSpecCodec.can_decodes >>- ..r*c|jj}t|tj|jj |tj|jj |r|SdS)NrrrM)rr4rrrrr)rAr decode_fnr4s r( do_decodez_TensorSpecCodec.do_decodes  " " ' 'D   & &#(#:#:#@#@ BC  & &#(#:#:#@#@ BCd ''!% ''r*NrNrOrPrQrrrrr7r*r(rrs6 / 'r*rztf.BoundedTensorSpecceZdZdZdZdfd ZedeejfdZ edejddfdZ dejfdZ ed Z ed Zed Zd Zd ZfdZdZdZdZxZS)ra0A `TensorSpec` that specifies minimum and maximum values. Example usage: ```python spec = tensor_spec.BoundedTensorSpec((1, 2, 3), tf.float32, 0, (5, 5, 5)) tf_minimum = tf.convert_to_tensor(spec.minimum, dtype=spec.dtype) tf_maximum = tf.convert_to_tensor(spec.maximum, dtype=spec.dtype) ``` Bounds are meant to be inclusive. This is especially important for integer types. The following spec will be satisfied by tensors with values in the set {0, 1, 2}: ```python spec = tensor_spec.BoundedTensorSpec((3, 5), tf.int32, 0, 2) ``` )_minimum_maximumcptt| |||| td| td t j |}t jtj||j  t j |}t jtj||j t j||jj|_ |jjd t j||jj|_|jjd y#t$r"}td|d|j d|d}~wwxYw#t$r"}td|d|j d|d}~wwxYw) aInitializes a new `BoundedTensorSpec`. Args: shape: Value convertible to `tf.TensorShape`. The shape of the tensor. dtype: Value convertible to `tf.DType`. The type of the tensor values. minimum: Number or sequence specifying the minimum element bounds (inclusive). Must be broadcastable to `shape`. maximum: Number or sequence specifying the maximum element bounds (inclusive). Must be broadcastable to `shape`. name: Optional string containing a semantic name for the corresponding array. Defaults to `None`. Raises: ValueError: If `minimum` or `maximum` are not provided or not broadcastable to `shape`. TypeError: If the shape is not an iterable or if the `dtype` is an invalid numpy dtype. Nz`minimum` can not be None.z`maximum` can not be None.z `minimum` z is not compatible with shape r z `maximum` )rF)write)rTrrDr#nprr broadcast_shaperrarrayras_numpy_dtypersetflagsr) rArrminimummaximumr4 minimum_shape exception maximum_shaperVs r(rDzBoundedTensorSpec.__init__sz& T+E5$? 3 44 3 44hhw'm##  " "= 14::?hhw'm##  " "= 14::?HHWDJJ,E,EFDMMM'HHWDJJ,E,EFDMMM'%   wi=djj\ K     wi=djj\ K  s1AE;AF  F%FF F5F00F5rc"tjS)zJReturns the type of proto associated with BoundedTensorSpec serialization.)rBoundedTensorSpecProtorHs r(rJz)BoundedTensorSpec.experimental_type_proto4s  , ,,r*rKc2ttjj|j|j t j|jt j|j|jr|jSdS)zCReturns a BoundedTensorSpec instance based on the serialized proto.Nrrrrr4) rrrrNrrr MakeNdarrayrrr4rOs r(rNz)BoundedTensorSpec.experimental_from_proto9sp &&>>u{{Kkk'' 6'' 6 ::UZZ  11 ,0  11r*c2tj|jj|jjj t j|jt j|j|jS)zAReturns a proto representation of the BoundedTensorSpec instance.r) rrrrQrrRrmake_tensor_protorrr4rGs r(rQz'BoundedTensorSpec.experimental_as_protoDsf  , ,jj..0jj..099--dmm<--dmm< YY  r*ctj|j}t|d|j}t|d|j }t |j||||jS)agReturns a `TensorSpec` with the same shape and dtype as `spec`. If `spec` is a `BoundedTensorSpec`, then the new spec's bounds are set to `spec.minimum` and `spec.maximum`; otherwise, the bounds are set to `spec.dtype.min` and `spec.dtype.max`. >>> spec = tf.TensorSpec(shape=[8, 3], dtype=tf.int32, name="x") >>> BoundedTensorSpec.from_spec(spec) BoundedTensorSpec(shape=(8, 3), dtype=tf.int32, name='x', minimum=array(-2147483648, dtype=int32), maximum=array(2147483647, dtype=int32)) Args: spec: The `TypeSpec` used to create the new `BoundedTensorSpec`. rr) r r'rrminmaxrrr4)rIrrrrs r(rzBoundedTensorSpec.from_specMsU" OODJJ 'EdIuyy1GdIuyy1G TZZ$)) LLr*c|jS)z@Returns a NumPy array specifying the minimum bounds (inclusive).)rrGs r(rzBoundedTensorSpec.minimumc ==r*c|jS)z@Returns a NumPy array specifying the maximum bounds (inclusive).)rrGs r(rzBoundedTensorSpec.maximumhrr*c|jr0t|tr |j|s Jd|d||St |j |j |j}|j||S)NrrrM) rrrrXrrrr4r)rArr actual_specs r(rzBoundedTensorSpec.castmsm""z%9J'K   &M-yTH(MM & k4::TZZdiiPK   E? 33r*c d}|j|jt|jt|jt|j t|j S)NzFBoundedTensorSpec(shape={}, dtype={}, name={}, minimum={}, maximum={}))r0rr1rr4rr)rAr[s r(rzBoundedTensorSpec.__repr__usJPA 88DJJTZZ 0$tyy/&T\\(: <Returns an encoded proto for the given `tf.BoundedTensorSpec`.)rrr4rr)rrbounded_tensor_spec_valuerrrrrrr4rrrr)rArrencoded_bounded_tensor_specs r(rz!_BoundedTensorSpecCodec.do_encodes","<"<">99BB))5;;<OO5;;<OO*//11)11311)113  45 '&r*c$|jdS)Nrrrs r(rz"_BoundedTensorSpecCodec.can_decodes >>5 66r*ch|j}|j}t|tj|j |tj|j tj|jtj|j|r|SdS)Nrrr) rr4rrrrrrrrr)rArrbtsvr4s r(rz!_BoundedTensorSpecCodec.do_decodes  * *D 99D   & &$** EG  & &$** EG'' 5'' 5d ''!% ''r*Nrr7r*r(rrs&0 '7 'r*rcBt|j|jSrFrrr)rBs r(rrs:fllFLLAr*cBt|j|jSrFr)rs r(rrsjekkBr*rF)KrQtypingrrnumpyrtensorflow.core.frameworkrtensorflow.core.functionrtensorflow.core.protobufrtensorflow.pythonrtensorflow.python.eagerr r r tensorflow.python.frameworkr r rrrrrrrrtensorflow.python.opsrtensorflow.python.platformrrtensorflow.python.saved_modelrtensorflow.python.typesrrrtensorflow.python.utilrrr tensorflow.python.util.tf_exportr BoolGauger r)r2r9objectr; NativeObjectrr!rr rrr!TypeSpecr#registerBatchableTypeSpec Serializablerregister_serializableregister_tensor_typerregister_codecrr'register_type_spec_from_value_converterndarrayr7r*r(r st%!4//!+.*5..4-B431:2<@9,).26$8:#7#7,5$7 ("%)P$(3f. 81xjAs X " "M$8$8s Bs l '() *  ()*+SS24D ""DN <_-l0I77(((*=*=l0.l0\ ! ,  +''@&%%&6&8934YP J$;$;YP5YPx!'!'H&%%&=&?@ !232 11 AC2 11JJBDr*