Input-output Jacobian difference as loss function

username: CindyXWu
cooked: <p>Referring to this forum post here which is the most relevant answer chain I have found to my question: <a href="https://discuss.pytorch.org/t/how-to-penalize-norm-of-end-to-end-jacobian/62771" class="inline-onebox">How to Penalize Norm of End-to-End Jacobian</a></p>
<p>I am trying to implement a knowledge distillation loss which penalises the Jacobian of the output wrt the input for teacher and student. However, my model is not training correctly and I think it is because the computational graph is not what I think it should be. I have tried two things:</p>
<ol>
<li>Using backward with create_graph = True</li>
</ol>
<pre><code class="lang-auto">def get_jacobian(output, x, batch_size, input_dim, output_dim):
    """In order to keep grads, need to set create_graph to True, but computation very slow."""
    assert x.requires_grad
    jacobian = torch.zeros(batch_size, output_dim, input_dim, device=x.device)
    for i in range(output_dim):
        grad_output = torch.zeros(batch_size, output_dim, device=x.device)
        grad_output[:, i] = 1
        output.backward(grad_output, create_graph=True)
        jacobian[:, i, :] = x.grad.view(batch_size, -1)
        x.grad.zero_()
    print("Jacobian for backward requires grad:", jacobian.requires_grad)
    return jacobian.view(batch_size, -1) # Flatten
</code></pre>
<p>Checking if I leave only retain_graph = True shows that the result no longer requires grad. At this point, I can force it to require grad by</p>
<pre><code class="lang-auto">jacobian.requires_grad = True
jacobian.retain_grad()
</code></pre>
<p>but I believe this does not attach the Jacobian back onto the computational graph (or does it?)</p>
<ol start="2">
<li>Autograd with retain_graph = True</li>
</ol>
<pre><code class="lang-auto">def get_jacobian(output, x, batch_size, input_dim, output_dim):
    jacobian = torch.zeros(batch_size, output_dim, input_dim, device=x.device)
    for i in range(output_dim):
        grad_output = torch.zeros(batch_size, output_dim, device=x.device)
        grad_output[:, i] = 1
        grad_input = torch.autograd.grad(output, x, grad_output, retain_graph=True)[0]
        jacobian[:, i, :] = grad_input.view(batch_size, input_dim)
    print("Jacobian as calculated requires grad:", jacobian.requires_grad)
    return jacobian.view(batch_size, -1) # Flatten
</code></pre>
<p>It’s also very hard to debug the cases where create_graph = True since the training takes so long. Can someone help me with a method that is guaranteed to retain the grads to the eventual loss function? Here is the loss computation code:</p>
<pre><code class="lang-auto">def jacobian_loss(scores, targets, inputs, T, alpha, batch_size, loss_fn, input_dim, output_dim):
    """Eq 10, no hard targets used.
    Args:
        scores: logits of student [batch_size, num_classes]
        targets: logits of teacher [batch_size, num_classes]
        inputs: [batch_size, input_dim, input_dim, channels]
        T: float, temperature
        alpha: float, weight of jacobian penalty
        loss_fn: for classical distill loss - MSE, BCE, KLDiv
    """
    # Only compute softmax for KL divergence loss
    if isinstance(loss_fn, nn.KLDivLoss):
        soft_pred = F.log_softmax(scores/T, dim=1)
        soft_targets = F.log_softmax(targets/T, dim=1)  # Have set log_target=True
    elif isinstance(loss_fn, nn.CrossEntropyLoss):
        soft_pred = scores/T
        soft_targets = F.softmax(targets/T).argmax(dim=1)
    elif isinstance(loss_fn, nn.MSELoss):
        soft_pred = F.softmax(scores/T, dim=1)
        soft_targets = F.softmax(targets/T, dim=1)
    else:
        raise ValueError("Loss function not supported.")
        
    # t_jac = get_jacobian(targets, inputs, batch_size, input_dim, output_dim)
    # s_jac = get_jacobian(scores, inputs, batch_size, input_dim, output_dim)

    t_jac = get_approx_jacobian(targets, inputs, batch_size, input_dim, output_dim)
    i = torch.argmax(targets, dim=1)
    s_jac = get_approx_jacobian(scores, inputs, batch_size, input_dim, output_dim, i)
    s_jac= torch.div(s_jac, torch.norm(s_jac, 2, dim=-1).unsqueeze(1))
    t_jac = torch.div(t_jac, torch.norm(t_jac, 2, dim=-1).unsqueeze(1))
    jacobian_loss = torch.norm(t_jac-s_jac, 2, dim=1)
    jacobian_loss = torch.mean(jacobian_loss)  # Batchwise reduction
    distill_loss = loss_fn(soft_pred, soft_targets)
    loss = (1-alpha) * distill_loss + alpha * jacobian_loss
    return  loss
</code></pre>
<p>Update:<br>
I believe using create_graph = True for both autograd and backward works better than retain_graph = True, but I am not sure why.</p>
<p>Update on update: It appears I have resolved this after some fiddling and as long as create_graph = True, the gradients propagate correctly. The same is not true for my other attempts to extract feature maps using hooks and use those in the loss function. I would still like to understand how this all works, though, so if someone could explain to me what is going on it would be great.</p>