Thanks AlphaBetaGamma96! That was a quick check on the `grad_fn`

!

One more question: if I use the indices returned from `torch.sort()`

and feed it to `torch.take()`

, will the gradients be backpropagated? (I think yes, and I posted my test code as follows.)

Test code:

```
import torch
from torch import nn
x = torch.tensor([1, 4, 7, 3, 9, 0], dtype=torch.float, requires_grad=True)
x_sorted = torch.sort(x)[0]
x_id = torch.sort(x)[1]
print(x_sorted, x_id)
y = torch.tensor([0, 1, 2, 3, 4, 5], dtype=torch.float, requires_grad=True)
y_sorted = torch.take(y, x_id) # Here is my question: Will the gradients be backpropagated?
print(y, y_sorted)
loss_mse = nn.MSELoss()
loss_xy = loss_mse(x, y)
loss_ys = y_sorted.mean()
loss_xs = x_sorted.mean()
loss_ys.backward()
loss_xs.backward()
loss_xy.backward()
print(f"Gradients: {loss_ys.item()}, {loss_xs.item()}, {loss_xy.item()}")
loss_xid = x_id.float().mean()
loss_xid.backward()
```

which returns

```
tensor([0., 1., 3., 4., 7., 9.], grad_fn=<SortBackward>) tensor([5, 0, 3, 1, 2, 4])
tensor([0., 1., 2., 3., 4., 5.], requires_grad=True) tensor([5., 0., 3., 1., 2., 4.], grad_fn=<TakeBackward>)
Gradients: 2.5, 4.0, 14.166666984558105
---------------------------------------------------------------------------
RuntimeError Traceback (most recent call last)
<ipython-input-30-1004213fe0c3> in <module>
20
21 loss_xid = x_id.float().mean()
---> 22 loss_xid.backward()
~/miniconda3/envs/base-tornado5/lib/python3.8/site-packages/torch/tensor.py in backward(self, gradient, retain_graph, create_graph, inputs)
243 create_graph=create_graph,
244 inputs=inputs)
--> 245 torch.autograd.backward(self, gradient, retain_graph, create_graph, inputs=inputs)
246
247 def register_hook(self, hook):
~/miniconda3/envs/base-tornado5/lib/python3.8/site-packages/torch/autograd/__init__.py in backward(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)
143 retain_graph = create_graph
144
--> 145 Variable._execution_engine.run_backward(
146 tensors, grad_tensors_, retain_graph, create_graph, inputs,
147 allow_unreachable=True, accumulate_grad=True) # allow_unreachable flag
RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn
```

It can be seen that gradients are calculated for `loss_ys`

(which does not have any actual meaning but only takes average on `y_sorted`

for testing purposes). And for `loss_xid`

, error popped up due to the lack of `grad_fn`

for `torch.sort(x)[1]`

just like AlphaBetaGamma96 pointed out. So my answer to my question is yes: `torch.take(y, x_id)`

supports gradient backpropagation with `x_id = torch.sort(x)[1]`

and `y`

being a tensor that has `requires_grad=True`

.

Let me know if I am making mistakes here. Thanks!