Unfortunately the value that is needed for the call to backward is not calculated until after the forward function.  So that would not work.
A global could possibly work, though I would then need to keep track of a separate ctx and some kind of intelligent indexing for every tensor that uses this function correct?
Essentially what I want to do is that the forward pass is just used to put the tensor in the autograd graph, and then the backward pass does its own thing that’s unrelated to the 0 gradient to calculate the gradient using an external value.  Here is a cropped piece of code which had been working in 0.3:
class tagger(torch.autograd.Function):
    def forward(self, inp):
        return inp.clone() * 0
    def backward(self, grad_out):
        grad_out = self.valueThatGetsFilledInOutsideThisFunction
        ....
        math
        ....        
        return grad_in

One thing I have just tried that appears to allow this to work is the following.  Does this seem like a reasonable solution or is this potentially dangerous:
class tagger2(torch.autograd.Function):
       @staticmethod
       def forward(ctx, inp, temp):
           ctx.save_for_backward(temp)
           return inp.clone() * 0, temp
        @staticmethod
        def backward(ctx, grad_out, temp_gradout):
           print(ctx.saved_tensors)
anotherFunction():
       applier = self.taggers[i].apply
       temp = torch.Tensor(1)
       data[i], tempOut = applier(data[i], temp)
       temp.data[0] = 12345

This does make the backward pass print 12345.  So I could easily just make a temps array the same size as the taggers array. but I don’t know for sure if its ok to modify something with .data.  If this does work shoud I also return None rather than returning temp which is meaningless?  And do I need an array of the taggers anymore or now that they are static functions I don’t need to keep track of them?