tf.TensorShape

View source on GitHub

Represents the shape of a Tensor.

View aliases

Compat aliases for migration

See Migration guide for more details.

tf.compat.v1.TensorShape

tf.TensorShape(
    dims
)

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 Shape functions for details of shape functions and how to register them. Alternatively, the shape may be set explicitly using tf.Tensor.set_shape.

Args
`dims`	A list of Dimensions, or None if the shape is unspecified.

Raises
`TypeError`	If dims cannot be converted to a list of dimensions.

Attributes

dims

Deprecated. Returns list of dimensions for this shape.

Suggest TensorShape.as_list instead.

ndims Deprecated accessor for rank.

rank Returns the rank of this shape, or None if it is unspecified.

Methods

`as_list`

as_list()

Returns 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.

`as_proto`

as_proto()

Returns this shape as a TensorShapeProto.

`assert_has_rank`

assert_has_rank(
    rank
)

Raises an exception if self is not compatible with the given rank.

Args
`rank`	An integer.

Raises
`ValueError`	If `self` does not represent a shape with the given `rank`.

`assert_is_compatible_with`

assert_is_compatible_with(
    other
)

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.

`assert_is_fully_defined`

assert_is_fully_defined()

Raises an exception if self is not fully defined in every dimension.

Raises
`ValueError`	If `self` does not have a known value for every dimension.

`assert_same_rank`

assert_same_rank(
    other
)

Raises an exception if self and other do not have compatible ranks.

Args
`other`	Another `TensorShape`.

Raises
`ValueError`	If `self` and `other` do not represent shapes with the same rank.

`concatenate`

concatenate(
    other
)

Returns the concatenation of the dimension in self and other.

Args
`other`	Another `TensorShape`.

Returns
A `TensorShape` whose dimensions are the concatenation of the dimensions in `self` and `other`.

`is_compatible_with`

is_compatible_with(
    other
)

Returns True iff self is compatible with other.

Two possibly-partially-defined shapes are compatible if there exists a fully-defined shape that both shapes can represent. Thus, compatibility allows the shape inference code to reason about partially-defined shapes. For example:

TensorShape(None) is compatible with all shapes.
TensorShape([None, None]) is compatible with all two-dimensional shapes, such as TensorShape([32, 784]), and also TensorShape(None). It is not compatible with, for example, TensorShape([None]) or TensorShape([None, None, None]).
TensorShape([32, None]) is compatible with all two-dimensional shapes with size 32 in the 0th dimension, and also TensorShape([None, None]) and TensorShape(None). It is not compatible with, for example, TensorShape([32]), TensorShape([32, None, 1]) or TensorShape([64, None]).
TensorShape([32, 784]) is compatible with itself, and also TensorShape([32, None]), TensorShape([None, 784]), TensorShape([None, None]) and TensorShape(None). It is not compatible with, for example, TensorShape([32, 1, 784]) or TensorShape([None]).

The compatibility relation is reflexive and symmetric, but not transitive. For example, TensorShape([32, 784]) is compatible with TensorShape(None), and TensorShape(None) is compatible with TensorShape([4, 4]), but TensorShape([32, 784]) is not compatible with TensorShape([4, 4]).

Args
`other`	Another TensorShape.

Returns
True iff `self` is compatible with `other`.

`is_fully_defined`

is_fully_defined()

Returns True iff self is fully defined in every dimension.

`merge_with`

merge_with(
    other
)

Returns a TensorShape combining the information in self and other.

The dimensions in self and other are merged element-wise, according to the rules below:

Dimension(n).merge_with(Dimension(None)) == Dimension(n)
Dimension(None).merge_with(Dimension(n)) == Dimension(n)
Dimension(None).merge_with(Dimension(None)) == Dimension(None)
# raises ValueError for n != m
Dimension(n).merge_with(Dimension(m))

ts = tf.TensorShape([1,2]) ot1 = tf.TensorShape([1,2]) ts.merge_with(ot).as_list() [1,2]

ot2 = tf.TensorShape([1,None]) ts.merge_with(ot2).as_list() [1,2]

ot3 = tf.TensorShape([None, None]) ot3.merge_with(ot2).as_list() [1, None]

Args
`other`	Another `TensorShape`.

Returns
A `TensorShape` containing the combined information of `self` and `other`.

Raises
`ValueError`	If `self` and `other` are not compatible.

`most_specific_compatible_shape`

most_specific_compatible_shape(
    other
)

Returns the most specific TensorShape compatible with self and other.

TensorShape([None, 1]) is the most specific TensorShape compatible with both TensorShape([2, 1]) and TensorShape([5, 1]). Note that TensorShape(None) is also compatible with above mentioned TensorShapes.
TensorShape([1, 2, 3]) is the most specific TensorShape compatible with both TensorShape([1, 2, 3]) and TensorShape([1, 2, 3]). There are more less specific TensorShapes compatible with above mentioned TensorShapes, e.g. TensorShape([1, 2, None]), TensorShape(None).

Args
`other`	Another `TensorShape`.

Returns
A `TensorShape` which is the most specific compatible shape of `self` and `other`.

`num_elements`

num_elements()

Returns the total number of elements, or none for incomplete shapes.

`with_rank`

with_rank(
    rank
)

Returns 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`.

`with_rank_at_least`

with_rank_at_least(
    rank
)

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`.

`with_rank_at_most`

with_rank_at_most(
    rank
)

Returns 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`.

`add`

__add__(
    other
)

`bool`

__bool__()

Returns True if this shape contains non-zero information.

`concat`

__concat__(
    other
)

`eq`

__eq__(
    other
)

Returns True if self is equivalent to other.

It first tries to convert other to TensorShape. TypeError is thrown when the conversion fails. Otherwise, it compares each element in the TensorShape dimensions.

Two Fully known shapes, return True iff each element is equal.

>>> t_a = tf.TensorShape([1,2])
>>> a = [1, 2]
>>> t_b = tf.TensorShape([1,2])
>>> t_c = tf.TensorShape([1,2,3])
>>> t_a.__eq__(a)
True
>>> t_a.__eq__(t_b)
True
>>> t_a.__eq__(t_c)
False

Two Partially-known shapes, return False.

>>> p_a = tf.TensorShape([1,None])
>>> p_b = tf.TensorShape([2,None])
>>> p_a.__eq__(p_b)
False
>>> t_a.__eq__(p_a)
False

Two Unknown shape, return True.

>>> unk_a = tf.TensorShape(None)
>>> unk_b = tf.TensorShape(None)
>>> unk_a.__eq__(unk_b)
True
>>> unk_a.__eq__(t_a)
False

Args
`other`	A `TensorShape` or type that can be converted to `TensorShape`.

Returns
True if the dimensions are all equal.

Raises
TypeError if `other` can not be converted to `TensorShape`.

`getitem`

__getitem__(
    key
)

Returns 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
An integer if `key` is an integer, or a `TensorShape` if `key` is a slice.

Raises
`ValueError`	If `key` is a slice and `self` is completely unknown and the step is set.

`iter`

__iter__()

Returns self.dims if the rank is known, otherwise raises ValueError.

`len`

__len__()

Returns the rank of this shape, or raises ValueError if unspecified.

`ne`

__ne__(
    other
)

Returns True if self is known to be different from other.

`nonzero`

__nonzero__()

Returns True if this shape contains non-zero information.

`radd`

__radd__(
    other
)

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see the Google Developers Site Policies. Java is a registered trademark of Oracle and/or its affiliates. Some content is licensed under the numpy license.

Last updated 2022-11-04 UTC.