Ctrl+K

flatten#

ivy.flatten(x, /, *, copy=None, start_dim=0, end_dim=-1, order='C', out=None)[source]#

Flattens input by reshaping it into a one-dimensional tensor. If start_dim or end_dim are passed, only dimensions starting with start_dim and ending with end_dim are flattened. The order of elements in input is unchanged.

Parameters:

  • x (Union[Array, NativeArray]) – input array to flatten.

  • copy (Optional[bool], default: None) – boolean indicating whether or not to copy the input array. If True, the function must always copy. If False, the function must never copy. In case copy is False we avoid copying by returning a view of the input array.

  • start_dim (int, default: 0) – first dim to flatten. If not set, defaults to 0.

  • end_dim (int, default: -1) – last dim to flatten. If not set, defaults to -1.

  • order (str, default: 'C') – Read the elements of the input container using this index order, and place the elements into the reshaped array using this index order. ‘C’ means to read / write the elements using C-like index order, with the last axis index changing fastest, back to the first axis index changing slowest. ‘F’ means to read / write the elements using Fortran-like index order, with the first index changing fastest, and the last index changing slowest. Note that the ‘C’ and ‘F’ options take no account of the memory layout of the underlying array, and only refer to the order of indexing. Default order is ‘C’

  • out (Optional[Array], default: None) – optional output array, for writing the result to.

Return type:

Array

Returns:

ret – the flattened array over the specified dimensions.

Examples

With ivy.Array input:

>>> x = ivy.array([[1,2], [3,4]])
>>> ivy.flatten(x)
ivy.array([1, 2, 3, 4])

>>> x = ivy.array([[1,2], [3,4]])
>>> ivy.flatten(x, order='F')
ivy.array([1, 3, 2, 4])

>>> x = ivy.array(
    [[[[ 5,  5,  0,  6],
     [17, 15, 11, 16],
     [ 6,  3, 13, 12]],
[[ 6, 18, 10, 4],

[ 5, 1, 17, 3], [14, 14, 18, 6]]],

[[[12, 0, 1, 13],

[ 8, 7, 0, 3], [19, 12, 6, 17]],

[[ 4, 15, 6, 15],

[ 0, 5, 17, 9], [ 9, 3, 6, 19]]],

[[[17, 13, 11, 16],

[ 4, 18, 17, 4], [10, 10, 9, 1]],

[[19, 17, 13, 10],

[ 4, 19, 16, 17], [ 2, 12, 8, 14]]]] )

>>> ivy.flatten(x, start_dim = 1, end_dim = 2)
ivy.array(
    [[[ 5,  5,  0,  6],
      [17, 15, 11, 16],
      [ 6,  3, 13, 12],
      [ 6, 18, 10,  4],
      [ 5,  1, 17,  3],
      [14, 14, 18,  6]],
[[12, 0, 1, 13],

[ 8, 7, 0, 3], [19, 12, 6, 17], [ 4, 15, 6, 15], [ 0, 5, 17, 9], [ 9, 3, 6, 19]],

[[17, 13, 11, 16],

[ 4, 18, 17, 4], [10, 10, 9, 1], [19, 17, 13, 10], [ 4, 19, 16, 17], [ 2, 12, 8, 14]]]))

Array.flatten(self, *, copy=None, start_dim=0, end_dim=-1, order='C', out=None)[source]#

ivy.Array instance method variant of ivy.flatten. This method simply wraps the function, and so the docstring for ivy.flatten also applies to this method with minimal changes.

Parameters:

  • self (Array) – input array to flatten.

  • copy (Optional[bool], default: None) –

    boolean indicating whether or not to copy the input array. If True, the function must always copy. If False, the function must never copy. In case copy is False we avoid copying by returning a

    view of the input array.

  • start_dim (int, default: 0) – first dim to flatten. If not set, defaults to 0.

  • end_dim (int, default: -1) – last dim to flatten. If not set, defaults to -1.

  • order (str, default: 'C') – Read the elements of the input container using this index order, and place the elements into the reshaped array using this index order. ‘C’ means to read / write the elements using C-like index order, with the last axis index changing fastest, back to the first axis index changing slowest. ‘F’ means to read / write the elements using Fortran-like index order, with the first index changing fastest, and the last index changing slowest. Note that the ‘C’ and ‘F’ options take no account of the memory layout of the underlying array, and only refer to the order of indexing. Default order is ‘C’.

  • out (Optional[Array], default: None) – Optional output, for writing the result to.

Return type:

Array

Returns:

ret – the flattened array over the specified dimensions.

Examples

>>> x = ivy.array([[1,2], [3,4]])
>>> x.flatten()
ivy.array([1, 2, 3, 4])

>>> x = ivy.array([[1,2], [3,4]])
>>> x.flatten(order='F')
ivy.array([1, 3, 2, 4])

>>> x = ivy.array(
    [[[[ 5,  5,  0,  6],
    [17, 15, 11, 16],
    [ 6,  3, 13, 12]],

[[ 6, 18, 10, 4], [ 5, 1, 17, 3], [14, 14, 18, 6]]],

[[[12, 0, 1, 13],

[ 8, 7, 0, 3], [19, 12, 6, 17]],

[[ 4, 15, 6, 15], [ 0, 5, 17, 9], [ 9, 3, 6, 19]]],

[[[17, 13, 11, 16],

[ 4, 18, 17, 4], [10, 10, 9, 1]],

[[19, 17, 13, 10], [ 4, 19, 16, 17], [ 2, 12, 8, 14]]]] )

>>> x.flatten(start_dim = 1, end_dim = 2)
ivy.array(
    [[[ 5,  5,  0,  6],
    [17, 15, 11, 16],
    [ 6,  3, 13, 12],
    [ 6, 18, 10,  4],
    [ 5,  1, 17,  3],
    [14, 14, 18,  6]],

[[12, 0, 1, 13], [ 8, 7, 0, 3], [19, 12, 6, 17], [ 4, 15, 6, 15], [ 0, 5, 17, 9], [ 9, 3, 6, 19]],

[[17, 13, 11, 16], [ 4, 18, 17, 4], [10, 10, 9, 1], [19, 17, 13, 10], [ 4, 19, 16, 17], [ 2, 12, 8, 14]]]))

Container.flatten(self, *, copy=None, start_dim=0, end_dim=-1, order='C', out=None)[source]#

ivy.Container instance method variant of ivy.flatten. This method simply wraps the function, and so the docstring for ivy.flatten also applies to this method with minimal changes.

Parameters:

  • self (Container) – input container to flatten at leaves.

  • copy (Optional[Union[bool, Container]], default: None) – boolean indicating whether or not to copy the input array. If True, the function must always copy. If False, the function must never copy and must raise a ValueError in case a copy would be necessary. If None, the function must reuse existing memory buffer if possible and copy otherwise. Default: None.

  • start_dim (Union[int, Container], default: 0) – first dim to flatten. If not set, defaults to 0.

  • end_dim (Union[int, Container], default: -1) – last dim to flatten. If not set, defaults to -1.

  • order (Union[str, Container], default: 'C') – Read the elements of the input container using this index order, and place the elements into the reshaped array using this index order. ‘C’ means to read / write the elements using C-like index order, with the last axis index changing fastest, back to the first axis index changing slowest. ‘F’ means to read / write the elements using Fortran-like index order, with the first index changing fastest, and the last index changing slowest. Note that the ‘C’ and ‘F’ options take no account of the memory layout of the underlying array, and only refer to the order of indexing. Default order is ‘C’

Return type:

Container

Returns:

ret – Container with arrays flattened at leaves.

Examples

With one ivy.Container input:

>>> x = ivy.Container(a=ivy.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]),
...                   b=ivy.array([[[9, 10], [11, 12]], [[13, 14], [15, 16]]]))
>>> x.flatten()
[{
    a: ivy.array([1, 2, 3, 4, 5, 6, 7, 8])
    b: ivy.array([9, 10, 11, 12, 13, 14, 15, 16])
}]

>>> x = ivy.Container(a=ivy.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]),
...                   b=ivy.array([[[9, 10], [11, 12]], [[13, 14], [15, 16]]]))
>>> x.flatten(order="F")
[{
    a: ivy.array([1, 5, 3, 7, 2, 6, 4, 8])
    b: ivy.array([9, 13, 11, 15, 10, 14, 12, 16])
}]
On this page