U Vc@s~dZddlmZmZddlmZGdddeZddZGd d d eZ d d Z dddZ e gZ ddZ ddZddZd S)z*Helper classes for tensor shape inference.)compatdtypes)tensor_shape_pb2c@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ e ddZ ddZddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Z d:S); Dimensionz7Represents the value of one dimension in a TensorShape.cCsr|dkrd|_n^t|tjr*td|nDt||_t|tjsV|j|krVtd||jdkrntd|jdS)z-Creates a new Dimension with the given value.NzCannot convert %s to DimensionzAmbiguous dimension: %srzDimension %d must be >= 0) _value isinstancerZDType TypeErrorintrbytes_or_text_types ValueErrorselfvaluerS/tmp/pip-unpacked-wheel-g8kmtpbc/tensorboard/compat/tensorflow_stub/tensor_shape.py__init__s     zDimension.__init__cCsdt|jS)Nz Dimension(%s))reprrrrrr__repr__)szDimension.__repr__cCs|j}|dkrdSt|S)N?)rstrr rrr__str__,szDimension.__str__c CsNz t|}Wnttfk r(tYSX|jdks>|jdkrBdS|j|jkS)zKReturns true if `other` has the same known value as this Dimension.N as_dimensionr r NotImplementedrrrotherrrr__eq__0s  zDimension.__eq__c CsNz t|}Wnttfk r(tYSX|jdks>|jdkrBdS|j|jkS)z@Returns true if `other` has a different known value from `self`.Nrrrrr__ne__;s  zDimension.__ne__cCs|jSNrrrrr__int__EszDimension.__int__cCs|jSr r!rrrr__long__JszDimension.__long__cCs|jSr r!rrrr __index__MszDimension.__index__cCs|jS)z6The value of this dimension, or None if it is unknown.r!rrrrrQszDimension.valuecCs(t|}|jdkp&|jdkp&|j|jkS)aYReturns true if `other` is convertible with this Dimension. Two known Dimensions are convertible if they have the same value. An unknown Dimension is convertible with all other Dimensions. Args: other: Another Dimension. Returns: True if this Dimension and `other` are convertible. Nrrrrrrris_convertible_withVs   zDimension.is_convertible_withcCs||std||fdS)aRaises an exception if `other` is not convertible with this Dimension. Args: other: Another Dimension. Raises: ValueError: If `self` and `other` are not convertible (see is_convertible_with). z(Dimensions %s and %s are not convertibleNr&r rrrrassert_is_convertible_withis  z$Dimension.assert_is_convertible_withcCs4t|}|||jdkr&t|jSt|jSdS)aKReturns a Dimension that combines the information in `self` and `other`. Dimensions are combined as follows: ```python tf.Dimension(n) .merge_with(tf.Dimension(n)) == tf.Dimension(n) tf.Dimension(n) .merge_with(tf.Dimension(None)) == tf.Dimension(n) tf.Dimension(None).merge_with(tf.Dimension(n)) == tf.Dimension(n) tf.Dimension(None).merge_with(tf.Dimension(None)) == tf.Dimension(None) tf.Dimension(n) .merge_with(tf.Dimension(m)) # raises ValueError for n != m ``` Args: other: Another Dimension. Returns: A Dimension containing the combined information of `self` and `other`. Raises: ValueError: If `self` and `other` are not convertible (see is_convertible_with). N)rr(rrrrrrr merge_withys    zDimension.merge_withcCs8t|}|jdks|jdkr$tdSt|j|jSdS)aBReturns the sum of `self` and `other`. Dimensions are summed as follows: ```python tf.Dimension(m) + tf.Dimension(n) == tf.Dimension(m + n) tf.Dimension(m) + tf.Dimension(None) == tf.Dimension(None) tf.Dimension(None) + tf.Dimension(n) == tf.Dimension(None) tf.Dimension(None) + tf.Dimension(None) == tf.Dimension(None) ``` Args: other: Another Dimension, or a value accepted by `as_dimension`. Returns: A Dimension whose value is the sum of `self` and `other`. Nrrrrrrrr__add__szDimension.__add__cCs||S)zReturns the sum of `other` and `self`. Args: other: Another Dimension, or a value accepted by `as_dimension`. Returns: A Dimension whose value is the sum of `self` and `other`. rrrrr__radd__s zDimension.__radd__cCs8t|}|jdks|jdkr$tdSt|j|jSdS)aXReturns the subtraction of `other` from `self`. Dimensions are subtracted as follows: ```python tf.Dimension(m) - tf.Dimension(n) == tf.Dimension(m - n) tf.Dimension(m) - tf.Dimension(None) == tf.Dimension(None) tf.Dimension(None) - tf.Dimension(n) == tf.Dimension(None) tf.Dimension(None) - tf.Dimension(None) == tf.Dimension(None) ``` Args: other: Another Dimension, or a value accepted by `as_dimension`. Returns: A Dimension whose value is the subtraction of `other` from `self`. Nr*rrrr__sub__szDimension.__sub__cCs8t|}|jdks|jdkr$tdSt|j|jSdS)zReturns the subtraction of `self` from `other`. Args: other: Another Dimension, or a value accepted by `as_dimension`. Returns: A Dimension whose value is the subtraction of `self` from `other`. Nr*rrrr__rsub__s zDimension.__rsub__c CsZz t|}Wnttfk r(tYSX|jdks>|jdkrFtdSt|j|jSdS)aJReturns the product of `self` and `other`. Dimensions are summed as follows: ```python tf.Dimension(m) * tf.Dimension(n) == tf.Dimension(m * n) tf.Dimension(m) * tf.Dimension(None) == tf.Dimension(None) tf.Dimension(None) * tf.Dimension(n) == tf.Dimension(None) tf.Dimension(None) * tf.Dimension(None) == tf.Dimension(None) ``` Args: other: Another Dimension, or a value accepted by `as_dimension`. Returns: A Dimension whose value is the product of `self` and `other`. Nrr r rrrrrrrr__mul__s  zDimension.__mul__cCs||S)zReturns the product of `self` and `other`. Args: other: Another Dimension, or a value accepted by `as_dimension`. Returns: A Dimension whose value is the product of `self` and `other`. rrrrr__rmul__s zDimension.__rmul__c CsZz t|}Wnttfk r(tYSX|jdks>|jdkrFtdSt|j|jSdS)aiReturns the quotient of `self` and `other` rounded down. Dimensions are divided as follows: ```python tf.Dimension(m) // tf.Dimension(n) == tf.Dimension(m // n) tf.Dimension(m) // tf.Dimension(None) == tf.Dimension(None) tf.Dimension(None) // tf.Dimension(n) == tf.Dimension(None) tf.Dimension(None) // tf.Dimension(None) == tf.Dimension(None) ``` Args: other: Another Dimension, or a value accepted by `as_dimension`. Returns: A `Dimension` whose value is the integer quotient of `self` and `other`. Nr/rrrr __floordiv__ s  zDimension.__floordiv__cCs8t|}|jdks|jdkr$tdSt|j|jSdS)aReturns the quotient of `other` and `self` rounded down. Args: other: Another Dimension, or a value accepted by `as_dimension`. Returns: A `Dimension` whose value is the integer quotient of `self` and `other`. Nr*rrrr __rfloordiv__%s zDimension.__rfloordiv__cCs||S)aDEPRECATED: Use `__floordiv__` via `x // y` instead. This function exists only for backwards convertibility purposes; new code should use `__floordiv__` via the syntax `x // y`. Using `x // y` communicates clearly that the result rounds down, and is forward convertible to Python 3. Args: other: Another `Dimension`. Returns: A `Dimension` whose value is the integer quotient of `self` and `other`. rrrrr__div__4szDimension.__div__c CsZz t|}Wnttfk r(tYSX|jdks>|jdkrFtdSt|j|jSdS)a:Returns `self` modulo `other`. Dimension moduli are computed as follows: ```python tf.Dimension(m) % tf.Dimension(n) == tf.Dimension(m % n) tf.Dimension(m) % tf.Dimension(None) == tf.Dimension(None) tf.Dimension(None) % tf.Dimension(n) == tf.Dimension(None) tf.Dimension(None) % tf.Dimension(None) == tf.Dimension(None) ``` Args: other: Another Dimension, or a value accepted by `as_dimension`. Returns: A Dimension whose value is `self` modulo `other`. Nr/rrrr__mod__Ds  zDimension.__mod__c Cs2z t|}Wnttfk r(tYSX||S)zReturns `other` modulo `self`. Args: other: Another Dimension, or a value accepted by `as_dimension`. Returns: A Dimension whose value is `other` modulo `self`. )rr r rrrrr__rmod___s   zDimension.__rmod__cCs0t|}|jdks|jdkr dS|j|jkSdS)aReturns True if `self` is known to be less than `other`. Dimensions are compared as follows: ```python (tf.Dimension(m) < tf.Dimension(n)) == (m < n) (tf.Dimension(m) < tf.Dimension(None)) == None (tf.Dimension(None) < tf.Dimension(n)) == None (tf.Dimension(None) < tf.Dimension(None)) == None ``` Args: other: Another Dimension. Returns: The value of `self.value < other.value` if both are known, otherwise None. Nr%rrrr__lt__nszDimension.__lt__cCs0t|}|jdks|jdkr dS|j|jkSdS)a.Returns True if `self` is known to be less than or equal to `other`. Dimensions are compared as follows: ```python (tf.Dimension(m) <= tf.Dimension(n)) == (m <= n) (tf.Dimension(m) <= tf.Dimension(None)) == None (tf.Dimension(None) <= tf.Dimension(n)) == None (tf.Dimension(None) <= tf.Dimension(None)) == None ``` Args: other: Another Dimension. Returns: The value of `self.value <= other.value` if both are known, otherwise None. Nr%rrrr__le__szDimension.__le__cCs0t|}|jdks|jdkr dS|j|jkSdS)aReturns True if `self` is known to be greater than `other`. Dimensions are compared as follows: ```python (tf.Dimension(m) > tf.Dimension(n)) == (m > n) (tf.Dimension(m) > tf.Dimension(None)) == None (tf.Dimension(None) > tf.Dimension(n)) == None (tf.Dimension(None) > tf.Dimension(None)) == None ``` Args: other: Another Dimension. Returns: The value of `self.value > other.value` if both are known, otherwise None. Nr%rrrr__gt__szDimension.__gt__cCs0t|}|jdks|jdkr dS|j|jkSdS)a9Returns True if `self` is known to be greater than or equal to `other`. Dimensions are compared as follows: ```python (tf.Dimension(m) >= tf.Dimension(n)) == (m >= n) (tf.Dimension(m) >= tf.Dimension(None)) == None (tf.Dimension(None) >= tf.Dimension(n)) == None (tf.Dimension(None) >= tf.Dimension(None)) == None ``` Args: other: Another Dimension. Returns: The value of `self.value >= other.value` if both are known, otherwise None. Nr%rrrr__ge__szDimension.__ge__cCs t|jffSr )rrrrrr __reduce__szDimension.__reduce__N)!__name__ __module__ __qualname____doc__rrrrrr"r#r$propertyrr&r(r)r+r,r-r.r0r1r2r3r4r5r6r7r8r9r:r;rrrrrs<      rcCst|tr|St|SdS)a_Converts the given value to a Dimension. A Dimension input will be returned unmodified. An input of `None` will be converted to an unknown Dimension. An integer input will be converted to a Dimension with that value. Args: value: The value to be converted. Returns: A Dimension corresponding to the given value. N)rrrrrrrs rc@seZdZdZddZddZddZedd Zej d d Zed d Z d dZ ddZ e Z ddZddZddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Z d7d8Z!d9S): TensorShapeaRepresents the shape of a `Tensor`. A `TensorShape` represents a possibly-partial shape specification for a `Tensor`. It may be one of the following: * *Fully-known shape:* has a known number of dimensions and a known size for each dimension. e.g. `TensorShape([16, 256])` * *Partially-known shape:* has a known number of dimensions, and an unknown size for one or more dimension. e.g. `TensorShape([None, 256])` * *Unknown shape:* has an unknown number of dimensions, and an unknown size in all dimensions. e.g. `TensorShape(None)` If a tensor is produced by an operation of type `"Foo"`, its shape may be inferred if there is a registered shape function for `"Foo"`. See @{$adding_an_op#shape-functions-in-c$`Shape functions in C++`} for details of shape functions and how to register them. Alternatively, the shape may be set explicitly using @{tf.Tensor.set_shape}. cCs|dkrd|_nt|tjr*td|nt|tjrX|jrDd|_qdd|jD|_nRt|t rl|j |_n>z t |}Wn tk rt |g|_YnXdd|D|_d|_ dS)a;Creates a new TensorShape with the given dimensions. Args: dims: A list of Dimensions, or None if the shape is unspecified. DEPRECATED: A single integer is treated as a singleton list. Raises: TypeError: If dims cannot be converted to a list of dimensions. NzRA string has ambiguous TensorShape, please wrap in a list or convert to an int: %scSs$g|]}t|jdkr|jndqS)N)rsize.0dimrrr sz(TensorShape.__init__..cSsg|] }t|qSr)rrFdrrrrH$s)_dimsrrr r rTensorShapeProto unknown_rankrGrBdimsiterr_ndims)rrNZ dims_iterrrrrs,       zTensorShape.__init__cCs d|jS)NzTensorShape(%r)rKrrrrr'szTensorShape.__repr__cCsD|jdkrdS|jdkr&d|jdSdddd|jDSdS) Nz rz(%s,)rz(%s)z, css|]}t|VqdSr )rrIrrr 0sz&TensorShape.__str__..)ndimsrKjoinrrrrr*s   zTensorShape.__str__cCs|jS)zJReturns a list of Dimensions, or None if the shape is unspecified.rQrrrrrN2szTensorShape.dimscCs||_d|_dSr )rKrP)rrNrrrrN8scCs.|jdkrdS|jdkr$t|j|_|jSdS)z=Returns the rank of this shape, or None if it is unspecified.N)rKrPlenrrrrrS=s    zTensorShape.ndimscCs|jdkrtd|jS)zLReturns the rank of this shape, or raises ValueError if unspecified.Nz2Cannot take the length of Shape with unknown rank.)rKr rSrrrr__len__Gs  zTensorShape.__len__cCs |jdk S)z9Returns True if this shape contains non-zero information.NrQrrrr__bool__PszTensorShape.__bool__cCs"|jdkrtdn t|jSdS)zNReturns `self.dims` if the rank is known, otherwise raises ValueError.Nz.Cannot iterate over a shape with unknown rank.)rKr rOrrrr__iter__Ws  zTensorShape.__iter__cCs|jdk r.t|tr"t|j|S|j|Snrt|tr|jdk rH|jnd}|j}|jdk rdtd|dkrrtS|dks|dkrtSt||dSnt dSdS)aIReturns the value of a dimension or a shape, depending on the key. Args: key: If `key` is an integer, returns the dimension at that index; otherwise if `key` is a slice, returns a TensorShape whose dimensions are those selected by the slice from `self`. Returns: A dimension if `key` is an integer, or a `TensorShape` if `key` is a slice. Raises: ValueError: If `key` is a slice, and any of its elements are negative, or if `self` is completely unknown and the step is set. NrzSteps are not yet handledrS) rKrslicerBstartstopstepr unknown_shaper)rkeyr[r\rrr __getitem___s     zTensorShape.__getitem__cCs.|r&d}|jD]}||j9}q|SdSdS)zLReturns the total number of elements, or none for incomplete shapes.rN)is_fully_definedrKr)rrDrGrrr num_elementss   zTensorShape.num_elementscCst|}|jdkr|Sz@||g}t|jD]\}}||||q0t|WStk rztd||fYnXdS)aReturns a `TensorShape` combining the information in `self` and `other`. The dimensions in `self` and `other` are merged elementwise, according to the rules defined for `Dimension.merge_with()`. Args: other: Another `TensorShape`. Returns: A `TensorShape` containing the combined information of `self` and `other`. Raises: ValueError: If `self` and `other` are not convertible. Nz$Shapes %s and %s are not convertible)as_shaperKassert_same_rank enumerateappendr)rBr )rrZnew_dimsirGrrrr)s    zTensorShape.merge_withcCs6t|}|jdks|jdkr"tSt|j|jSdS)aReturns the concatenation of the dimension in `self` and `other`. *N.B.* If either `self` or `other` is completely unknown, concatenation will discard information about the other shape. In future, we might support concatenation that preserves this information for use with slicing. Args: other: Another `TensorShape`. Returns: A `TensorShape` whose dimensions are the concatenation of the dimensions in `self` and `other`. N)rcrKrNr^rBrrrr concatenateszTensorShape.concatenatecCs<t|}|jdk r8|jdk r8|j|jkr8td||fdS)aRaises an exception if `self` and `other` do not have convertible ranks. Args: other: Another `TensorShape`. Raises: ValueError: If `self` and `other` do not represent shapes with the same rank. Nz(Shapes %s and %s must have the same rank)rcrSr rrrrrds   zTensorShape.assert_same_rankcCs"|jd|fkrtd||fdS)zRaises an exception if `self` is not convertible with the given `rank`. Args: rank: An integer. Raises: ValueError: If `self` does not represent a shape with the given `rank`. NShape %s must have rank %drSr rZrankrrrassert_has_ranks zTensorShape.assert_has_rankcCs<z|t|dWStk r6td||fYnXdS)aReturns a shape based on `self` with the given rank. This method promotes a completely unknown shape to one with a known rank. Args: rank: An integer. Returns: A shape that is at least as specific as `self` with the given rank. Raises: ValueError: If `self` does not represent a shape with the given `rank`. rYriN)r)r^r rkrrr with_rankszTensorShape.with_rankcCs.|jdk r&|j|kr&td||fn|SdS)a\Returns a shape based on `self` with at least the given rank. Args: rank: An integer. Returns: A shape that is at least as specific as `self` with at least the given rank. Raises: ValueError: If `self` does not represent a shape with at least the given `rank`. Nz#Shape %s must have rank at least %drjrkrrrwith_rank_at_leasts  zTensorShape.with_rank_at_leastcCs.|jdk r&|j|kr&td||fn|SdS)aYReturns a shape based on `self` with at most the given rank. Args: rank: An integer. Returns: A shape that is at least as specific as `self` with at most the given rank. Raises: ValueError: If `self` does not represent a shape with at most the given `rank`. Nz"Shape %s must have rank at most %drjrkrrrwith_rank_at_mosts  zTensorShape.with_rank_at_mostcCsXt|}|jdk rT|jdk rT|j|jkr,dSt|j|jD]\}}||s:dSq:dS)aReturns True iff `self` is convertible with `other`. Two possibly-partially-defined shapes are convertible if there exists a fully-defined shape that both shapes can represent. Thus, convertibility allows the shape inference code to reason about partially-defined shapes. For example: * TensorShape(None) is convertible with all shapes. * TensorShape([None, None]) is convertible with all two-dimensional shapes, such as TensorShape([32, 784]), and also TensorShape(None). It is not convertible with, for example, TensorShape([None]) or TensorShape([None, None, None]). * TensorShape([32, None]) is convertible with all two-dimensional shapes with size 32 in the 0th dimension, and also TensorShape([None, None]) and TensorShape(None). It is not convertible with, for example, TensorShape([32]), TensorShape([32, None, 1]) or TensorShape([64, None]). * TensorShape([32, 784]) is convertible with itself, and also TensorShape([32, None]), TensorShape([None, 784]), TensorShape([None, None]) and TensorShape(None). It is not convertible with, for example, TensorShape([32, 1, 784]) or TensorShape([None]). The convertibility relation is reflexive and symmetric, but not transitive. For example, TensorShape([32, 784]) is convertible with TensorShape(None), and TensorShape(None) is convertible with TensorShape([4, 4]), but TensorShape([32, 784]) is not convertible with TensorShape([4, 4]). Args: other: Another TensorShape. Returns: True iff `self` is convertible with `other`. NFT)rcrKrNrSzipr&)rrZx_dimZy_dimrrrr&*s%  zTensorShape.is_convertible_withcCs||std||fdS)a`Raises exception if `self` and `other` do not represent the same shape. This method can be used to assert that there exists a shape that both `self` and `other` represent. Args: other: Another TensorShape. Raises: ValueError: If `self` and `other` do not represent the same shape. z"Shapes %s and %s are inconvertibleNr'rrrrr(Xs  z&TensorShape.assert_is_convertible_withcCst|}|jdks(|jdks(|j|jkr.tStdg|j}tt|j|jD],\}\}}|dk rP|dk rP||krP|||<qPt|S)a/Returns the most specific TensorShape convertible with `self` and `other`. * TensorShape([None, 1]) is the most specific TensorShape convertible with both TensorShape([2, 1]) and TensorShape([5, 1]). Note that TensorShape(None) is also convertible with above mentioned TensorShapes. * TensorShape([1, 2, 3]) is the most specific TensorShape convertible with both TensorShape([1, 2, 3]) and TensorShape([1, 2, 3]). There are more less specific TensorShapes convertible with above mentioned TensorShapes, e.g. TensorShape([1, 2, None]), TensorShape(None). Args: other: Another `TensorShape`. Returns: A `TensorShape` which is the most specific convertible shape of `self` and `other`. N) rcrKrNrSr^rrerprB)rrrNrgd1Zd2rrrmost_specific_convertible_shapejs  z+TensorShape.most_specific_convertible_shapecCs|jdk otdd|jDS)z.)rKallrrrrraszTensorShape.is_fully_definedcCs|std|dS)zRaises an exception if `self` is not fully defined in every dimension. Raises: ValueError: If `self` does not have a known value for every dimension. zShape %s is not fully definedN)rar rrrrassert_is_fully_definedsz#TensorShape.assert_is_fully_definedcCs"|jdkrtddd|jDS)zReturns a list of integers or `None` for each dimension. Returns: A list of integers or `None` for each dimension. Raises: ValueError: If `self` is an unknown shape with an unknown rank. Nz3as_list() is not defined on an unknown TensorShape.cSsg|] }|jqSrrArErrrrHsz'TensorShape.as_list..)rKr rrrras_lists zTensorShape.as_listcCs2|jdkrtjddStjdd|jDdSdS)z+Returns this shape as a `TensorShapeProto`.NT)rMcSs*g|]"}tjj|jdkrdn|jdqS)NrC)rD)rrLZDimrrIrrrrHsz(TensorShape.as_proto..)rG)rKrrLrrrras_protos  zTensorShape.as_protocCs2z t|}Wntk r$tYSX|j|jkS)z0Returns True if `self` is equivalent to `other`.)rcr rrKrNrrrrrs   zTensorShape.__eq__cCs^z t|}Wntk r$tYSX|jdks:|jdkrBtd|j|jkrRdS|j|jkS)z=Returns True if `self` is known to be different from `other`.Nz4The inequality of unknown TensorShapes is undefined.T)rcr rrSr rKrNrrrrrs   zTensorShape.__ne__cCs t|jffSr )rBrKrrrrr;szTensorShape.__reduce__N)"r<r=r>r?rrrr@rNsetterrSrVrW __nonzero__rXr`rbr)rhrdrlrmrnror&r(rrrartrurvrrr;rrrrrBsB(    ,   .# rBcCst|tr|St|SdS)z+Converts the given object to a TensorShape.N)rrB)shaperrrrcs rcNcCs&|dkrtdSttdg|SdS)zReturns an unknown TensorShape, optionally with a known rank. Args: ndims: (Optional) If specified, the number of dimensions in the shape. Returns: An unknown TensorShape. N)rBrrYrrrr^s r^cCstS)z&Returns a shape representing a scalar.) _SCALAR_SHAPErrrrscalarsr{cCs t|gS)zReturns a shape representing a vector. Args: length: The length of the vector, which may be None if unknown. Returns: A TensorShape representing a vector of the given length. rB)lengthrrrvectors r~cCs t||gS)aReturns a shape representing a matrix. Args: rows: The number of rows in the matrix, which may be None if unknown. cols: The number of columns in the matrix, which may be None if unknown. Returns: A TensorShape representing a matrix of the given size. r|)Zrowscolsrrrmatrixs r)N)r?rrZtensorboard.compat.protorobjectrrrBrcr^rzr{r~rrrrrs" Dl