tensorflow::ops::Reshape

#include <array_ops.h>

Reshapes a tensor.

Summary

Given tensor, this operation returns a tensor that has the same values as tensor with shape shape.

If one component of shape is the special value -1, the size of that dimension is computed so that the total size remains constant. In particular, a shape of [-1] flattens into 1-D. At most one component of shape can be -1.

If shape is 1-D or higher, then the operation returns a tensor with shape shape filled with the values of tensor. In this case, the number of elements implied by shape must be the same as the number of elements in tensor.

For example:

```prettyprint tensor 't' is [1, 2, 3, 4, 5, 6, 7, 8, 9]

tensor 't' has shape [9]

reshape(t, [3, 3]) ==> [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

tensor 't' is [[[1, 1], [2, 2]],

[[3, 3], [4, 4]]]

tensor 't' has shape [2, 2, 2]

reshape(t, [2, 4]) ==> [[1, 1, 2, 2], [3, 3, 4, 4]]

tensor 't' is [[[1, 1, 1],

[2, 2, 2]],

[[3, 3, 3],

[4, 4, 4]],

[[5, 5, 5],

[6, 6, 6]]]

tensor 't' has shape [3, 2, 3]

pass '[-1]' to flatten 't'

reshape(t, [-1]) ==> [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6]

-1 can also be used to infer the shape

-1 is inferred to be 9:

reshape(t, [2, -1]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3], [4, 4, 4, 5, 5, 5, 6, 6, 6]] -1 is inferred to be 2:

reshape(t, [-1, 9]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3], [4, 4, 4, 5, 5, 5, 6, 6, 6]] -1 is inferred to be 3:

reshape(t, [ 2, -1, 3]) ==> [[[1, 1, 1], [2, 2, 2], [3, 3, 3]], [[4, 4, 4], [5, 5, 5], [6, 6, 6]]]

tensor 't' is [7]

shape [] reshapes to a scalar

reshape(t, []) ==> 7 ```

Arguments:

• scope: A Scope object
• shape: Defines the shape of the output tensor.

Returns:

• Output: The output tensor.

Public attributes

::tensorflow::Output output

Public functions

 Reshape(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input tensor,
  ::tensorflow::Input shape
)

::tensorflow::Node * node() const 

operator::tensorflow::Input() const 

operator::tensorflow::Output() const