Hi,
I am implementing custom autograd functions on Sparse Tensors. As I use COO format to encode sparse tensors, the input of my auto grad functions is a pair of tensors, one containing the indices of type torch(.cuda).IntTensor and one containing the values of type torch(.cuda).FloatTensor.
The indice tensor do not have gradient (None) but is used to compute the gradient with respect to the value tensor. It seems that there has been an update in PyTorch 1.3 that do not allow this type of autograd function anymore. Indeed, my custom functions used to work under PyTorch 1.2 but it now raise the following error:
RuntimeError: Expected isFloatingType(grads[i].type().scalarType()) to be true, but got false.  (Could this error message be improved?  If so, please report an enhancement request to PyTorch.)

Here is a small reproducible exemple:
import torch
import torch.nn 
import torch.nn.functional as F



class test_discrete_grad_1(torch.autograd.Function):
    
    @staticmethod
    def forward(ctx, ind, val):
        size_table = ind.max(dim=1)[1]
        ctx.ind = ind
        new_ind = ind
        new_ind[1] = (new_ind[1] + 5)%(size_table[1].item()) 
        new_val = val * 3
        return new_ind, new_val

    @staticmethod
    def backward(ctx, grad_ind, grad_val):
        ### grad_ind is supposed to be None
        return None, 3 * grad_val


class test_discrete_grad_2(torch.autograd.Function):
    
    @staticmethod
    def forward(ctx, ind, val):
        ctx.ind = ind 
        res = torch.zeros((2,))
        res[0] = 2 * val[(ind[1]%2)==0].sum()
        res[1] = 5 * val[(ind[1]%2)==1].sum()
        return res

    @staticmethod
    def backward(ctx, grad):
        ind = ctx.ind
        val = torch.zeros((ind.size(1),))
        val[(ind[1]%2)==0] = 2 * grad[0]
        val[(ind[1]%2)==1] = 5 * grad[1]
        return None, val


def test():

    ind = torch.randint(low=0, high=30, size=(3, 20))
    val = torch.rand(20)
    val.requires_grad = True
    opp_1 = test_discrete_grad_1.apply
    opp_2 = test_discrete_grad_2.apply
    new_ind, new_val = opp_1(ind, val)
    res = opp_2(new_ind, new_val)
    print(res)
    out = res.sum()
    out.backward()
    print(val.grad)

test()

This script runs properly on PyTorch 1.2 and raises the previous error on Pytorch >1.3.
Is there a way to solve this without casting the indice tensor to Float type? (in my application it would requires A LOT of casting operations).
Thank you in advance.
Samuel