# tensorflow::ops::GatherNd

`#include <array_ops.h>`

Gather values or slices from `params` according to `indices`.

## Summary

`params` is a Tensor of rank `P` and `indices` is a Tensor of rank `Q`.

`indices` must be integer tensor, containing indices into `params`. It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.

The innermost dimension of `indices` (with length `K`) corresponds to indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th dimension of `params`.

Produces an output tensor with shape

``` [d_0, ..., d_{Q-2}, params.shape[K], ..., params.shape[P-1]]. ```

Some examples below.

Simple indexing into a matrix:

```python indices = [[0, 0], [1, 1]] params = [['a', 'b'], ['c', 'd']] output = ['a', 'd'] ```

Slice indexing into a matrix:

```python indices = [[1], [0]] params = [['a', 'b'], ['c', 'd']] output = [['c', 'd'], ['a', 'b']] ```

Indexing into a 3-tensor:

```python indices = [[1]] params = [[['a0', 'b0'], ['c0', 'd0']], [['a1', 'b1'], ['c1', 'd1']]] output = [[['a1', 'b1'], ['c1', 'd1']]]

```indices = [[0, 1], [1, 0]]
params = [[['a0', 'b0'], ['c0', 'd0']],
[['a1', 'b1'], ['c1', 'd1']]]
output = [['c0', 'd0'], ['a1', 'b1']]

indices = [[0, 0, 1], [1, 0, 1]]
params = [[['a0', 'b0'], ['c0', 'd0']],
[['a1', 'b1'], ['c1', 'd1']]]
output = ['b0', 'b1']
```
```

Batched indexing into a matrix:

```python indices = [[[0, 0]], [[0, 1]]] params = [['a', 'b'], ['c', 'd']] output = [['a'], ['b']] ```

Batched slice indexing into a matrix:

```python indices = [[[1]], [[0]]] params = [['a', 'b'], ['c', 'd']] output = [[['c', 'd']], [['a', 'b']]] ```

Batched indexing into a 3-tensor:

```python indices = [[[1]], [[0]]] params = [[['a0', 'b0'], ['c0', 'd0']], [['a1', 'b1'], ['c1', 'd1']]] output = [[[['a1', 'b1'], ['c1', 'd1']]], [[['a0', 'b0'], ['c0', 'd0']]]]

indices = [[[0, 1], [1, 0]], [[0, 0], [1, 1]]] params = [[['a0', 'b0'], ['c0', 'd0']], [['a1', 'b1'], ['c1', 'd1']]] output = [[['c0', 'd0'], ['a1', 'b1']], [['a0', 'b0'], ['c1', 'd1']]]

```indices = [[[0, 0, 1], [1, 0, 1]], [[0, 1, 1], [1, 1, 0]]]
params = [[['a0', 'b0'], ['c0', 'd0']],
[['a1', 'b1'], ['c1', 'd1']]]
output = [['b0', 'b1'], ['d0', 'c1']]
```
```

Arguments:

• scope: A Scope object
• params: `P-D`. The tensor from which to gather values.
• indices: `Q-D`. Index tensor having shape `[d_0, ..., d_{Q-2}, K]`.

Returns:

• `Output`: `(P+Q-K-1)-D`. Values from `params` gathered from indices given by `indices`.

### Constructors and Destructors

`GatherNd(const ::tensorflow::Scope & scope, ::tensorflow::Input params, ::tensorflow::Input indices)`

### Public attributes

`output`
`::tensorflow::Output`

### Public functions

`node() const `
`::tensorflow::Node *`
`operator::tensorflow::Input() const `
``` ```
``` ```
`operator::tensorflow::Output() const `
``` ```
``` ```

## Public attributes

### output

`::tensorflow::Output output`

## Public functions

### GatherNd

``` GatherNd(
const ::tensorflow::Scope & scope,
::tensorflow::Input params,
::tensorflow::Input indices
)```

### node

`::tensorflow::Node * node() const `

### operator::tensorflow::Input

` operator::tensorflow::Input() const `

### operator::tensorflow::Output

` operator::tensorflow::Output() const `