tensorflow::Tensor

Fills in proto with *this tensor's content.

AsProtoField() fills in the repeated field for proto.dtype(), while AsProtoTensorContent() encodes the content in proto.tensor_content() in a compact form.

Copy the other tensor into this tensor, reshape it and reinterpret the buffer's datatype.

If Status::OK() is returned, the two tensors now share the same underlying storage.

This call requires that the other tensor and the given type and shape are "compatible" (i.e. they occupy the same number of bytes).

Specifically:

shape.num_elements() * DataTypeSize(type)

must equal

other.num_elements() * DataTypeSize(other.dtype())

In addition, this function requires:

• DataTypeSize(other.dtype()) != 0
• DataTypeSize(type) != 0

If any of the requirements are not met, errors::InvalidArgument is returned.

Copy the other tensor into this tensor and reshape it.

This tensor shares other's underlying storage. Returns true iff other.shape() has the same number of elements of the given shape.

A human-readable summary of the tensor suitable for debugging.

Fill in the TensorDescription proto with metadata about the tensor that is useful for monitoring and debugging.

Parse other and construct the tensor.

Returns true iff the parsing succeeds. If the parsing fails, the state of *this is unchanged.

Returns true iff this tensor is aligned.

If necessary, has this Tensor been initialized?

Zero-element Tensors are always considered initialized, even if they have never been assigned to and do not have any memory allocated.

Convenience accessor for the tensor shape.

Slice this tensor along the 1st dimension.

I.e., the returned tensor satisfies returned[i, ...] == this[dim0_start + i, ...]. The returned tensor shares the underlying tensor buffer with this tensor.

NOTE: The returned tensor may not satisfy the same alignment requirement as this tensor depending on the shape. The caller must check the returned tensor's alignment before calling certain methods that have alignment requirement (e.g., flat(), tensor()).

NOTE: When fed with an N-dimensional tensor, this method returns a tensor also with N dimensions. If you want to select a sub tensor, see SubSlice.

REQUIRES: dims() >= 1 REQUIRES: 0 <= dim0_start <= dim0_limit <= dim_size(0)

Select a subslice from this tensor along the 1st dimension.

When fed with an N-dimensional tensor, this method returns a tensor with N-1 dimensions, where the returned tensor is a subslice of the input tensor along the first dimension. The N-1 dimensions of the returned tensor are the last N-1 dimensions of the input tensor.

NOTE: The returned tensor may not satisfy the same alignment requirement as this tensor depending on the shape. The caller must check the returned tensor's alignment before calling certain methods that have alignment requirement (e.g., flat(), tensor()).

REQUIRES: dims() >= 1 REQUIRES: 0 <= index < dim_size(0)

Render the first max_entries values in *this into a string.

Creates a 1-dimensional, 0-element float tensor.

The returned Tensor is not a scalar (shape {}), but is instead an empty one-dimensional Tensor (shape {0}, NumElements() == 0). Since it has no elements, it does not need to be assigned a value and is initialized by default (IsInitialized() is true). If this is undesirable, consider creating a one-element scalar which does require initialization:

Tensor(DT_FLOAT, TensorShape({}))

Creates a Tensor of the given type and shape.

If LogMemory::IsEnabled() the allocation is logged as coming from an unknown kernel and step. Calling the Tensor constructor directly from within an Op is deprecated: use the OpKernelConstruction/OpKernelContext allocate_* methods to allocate a new tensor, which record the kernel and step.

The underlying buffer is allocated using a CPUAllocator.

Creates a tensor with the input type and shape, using the allocator a to allocate the underlying buffer.

If LogMemory::IsEnabled() the allocation is logged as coming from an unknown kernel and step. Calling the Tensor constructor directly from within an Op is deprecated: use the OpKernelConstruction/OpKernelContext allocate_* methods to allocate a new tensor, which record the kernel and step.

a must outlive the lifetime of this Tensor.

Creates a tensor with the input type and shape, using the allocator a and the specified "allocation_attr" to allocate the underlying buffer.

If the kernel and step are known allocation_attr.allocation_will_be_logged should be set to true and LogMemory::RecordTensorAllocation should be called after the tensor is constructed. Calling the Tensor constructor directly from within an Op is deprecated: use the OpKernelConstruction/OpKernelContext allocate_* methods to allocate a new tensor, which record the kernel and step.

a must outlive the lifetime of this Tensor.

Creates a tensor with the input datatype, shape and buf.

Acquires a ref on buf that belongs to this Tensor.

Creates a tensor with the input datatype, shape and buf.

Takes an ownership of the bufffer from the reference counted pointer.

Creates an empty Tensor of the given data type.

Like Tensor(), returns a 1-dimensional, 0-element Tensor with IsInitialized() returning True. See the Tensor() documentation for details.

Copy constructor.

Move constructor.

After this call, is safely destructible can be assigned to, and IsInitialized() can be called and will return false. Other calls on (e.g. shape manipulation) are not valid.

Returns the estimated memory usage of this tensor.

Like BitcastFrom, but CHECK fails if any preconditions are not met.

Deprecated. Use BitcastFrom instead and check the returned Status.

Return the tensor data to an Eigen::Tensor with the new shape specified in new_sizes and cast to a new dtype T.

Using a bitcast is useful for move and copy operations. The allowed bitcast is the only difference from shaped().

Return the tensor data to an Eigen::Tensor with the new shape specified in new_sizes and cast to a new dtype T.

Using a bitcast is useful for move and copy operations. The allowed bitcast is the only difference from shaped().

Return the tensor data to an Eigen::Tensor with the same size but a bitwise cast to the specified dtype T.

Using a bitcast is useful for move and copy operations. NOTE: this is the same as tensor() except a bitcast is allowed.

Return the tensor data to an Eigen::Tensor with the same size but a bitwise cast to the specified dtype T.

Using a bitcast is useful for move and copy operations. NOTE: this is the same as tensor() except a bitcast is allowed.

Convenience accessor for the tensor shape.

Convenience accessor for the tensor shape.

For all shape accessors, see comments for relevant methods of TensorShape in tensor_shape.h.

Returns the data type.

Return the tensor data as an Eigen::Tensor of the data type and a specified shape.

These methods allow you to access the data with the dimensions and sizes of your choice. You do not need to know the number of dimensions of the Tensor to call them. However, they CHECK that the type matches and the dimensions requested creates an Eigen::Tensor with the same number of elements as the tensor.

Example:

  
    typedef float T;
    Tensor my_ten(...built with Shape{planes: 4, rows: 3, cols: 5}...);
    // 1D Eigen::Tensor, size 60:
    auto flat = my_ten.flat();
    // 2D Eigen::Tensor 12 x 5:
    auto inner = my_ten.flat_inner_dims();
    // 2D Eigen::Tensor 4 x 15:
    auto outer = my_ten.shaped, 2="">({4, 15});
    // CHECK fails, bad num elements:
    auto outer = my_ten.shaped, 2="">({4, 8});
    // 3D Eigen::Tensor 6 x 5 x 2:
    auto weird = my_ten.shaped, 3="">({6, 5, 2});
    // CHECK fails, type mismatch:
    auto bad   = my_ten.flat();</t,></t,></t,>

Returns the data as an Eigen::Tensor with NDIMS dimensions, collapsing all Tensor dimensions but the last NDIMS-1 into the first dimension of the result.

If NDIMS > dims() then leading dimensions of size 1 will be added to make the output rank NDIMS.

Returns the data as an Eigen::Tensor with NDIMS dimensions, collapsing the first 'begin' Tensor dimensions into the first dimension of the result and the Tensor dimensions of the last dims() - 'begin' - NDIMS into the last dimension of the result.

If 'begin' < 0 then the |'begin'| leading dimensions of size 1 will be added. If 'begin' + NDIMS > dims() then 'begin' + NDIMS - dims() trailing dimensions of size 1 will be added.

Returns the data as an Eigen::Tensor with NDIMS dimensions, collapsing all Tensor dimensions but the first NDIMS-1 into the last dimension of the result.

If NDIMS > dims() then trailing dimensions of size 1 will be added to make the output rank NDIMS.

Assign operator. This tensor shares other's underlying storage.

Move operator. See move constructor for details.

Return the tensor data to an Eigen::Tensor with the last dimension elements converted into single elements of a larger type.

For example, this is useful for kernels that can treat NCHW_VECT_C int8 tensors as NCHW int32 tensors. The sizeof(T) should equal the size of the original element type * num elements in the original last dimension. NDIMS should be 1 less than the original number of dimensions.

Return the tensor data to an Eigen::Tensor with the last dimension elements converted into single elements of a larger type.

For example, this is useful for kernels that can treat NCHW_VECT_C int8 tensors as NCHW int32 tensors. The sizeof(T) should equal the size of the original element type * num elements in the original last dimension. NDIMS should be 1 less than the original number of dimensions.

Return the Tensor data as a TensorMap of fixed size 1: TensorMap>.

Using scalar() allows the compiler to perform optimizations as the size of the tensor is known at compile time.

Returns the shape of the tensor.

Returns a StringPiece mapping the current tensor's buffer.

The returned StringPiece may point to memory location on devices that the CPU cannot address directly.

NOTE: The underlying tensor buffer is refcounted, so the lifetime of the contents mapped by the StringPiece matches the lifetime of the buffer; callers should arrange to make sure the buffer does not get destroyed while the StringPiece is still used.

REQUIRES: DataTypeCanUseMemcpy(dtype()).

Return the tensor data as an Eigen::Tensor with the type and sizes of this Tensor.

Use these methods when you know the data type and the number of dimensions of the Tensor and you want an Eigen::Tensor automatically sized to the Tensor sizes. The implementation check fails if either type or sizes mismatch.

Example:

  
    typedef float T;
    Tensor my_mat(...built with Shape{rows: 3, cols: 5}...);
    auto mat = my_mat.matrix();    // 2D Eigen::Tensor, 3 x 5.
    auto mat = my_mat.tensor, 2="">(); // 2D Eigen::Tensor, 3 x 5.
    auto vec = my_mat.vec();       // CHECK fails as my_mat is 2D.
    auto vec = my_mat.tensor, 3="">(); // CHECK fails as my_mat is 2D.
    auto mat = my_mat.matrix();// CHECK fails as type mismatch.</t,></t,>

Const versions of all the methods above.

Initializes a tensor with the input type and shape, or returns an error and leaves out_tensor unmodified.

This factory method should be used instead of the corresponding constructor if calling code cannot validate that the DataType is valid and supported.

The underlying buffer is allocated using a CPUAllocator.