mcy98's picture
Upload folder using huggingface_hub
4f873ad verified
Raw History Blame Contribute Delete
5.13 kB
# Copyright (c) 2020, Ahmed M. Alaa
# Licensed under the BSD 3-clause license (see LICENSE.txt)
# ---------------------------------------------------------
# Helper functions for influence functions'
# computation in Pytorch
# ---------------------------------------------------------
import collections
import copy
import numpy as np
import torch
def stack_torch_tensors(input_tensors):
"""
Takes a list of tensors and stacks them into one tensor
"""
unrolled = [input_tensors[k].view(-1, 1) for k in range(len(input_tensors))]
return torch.cat(unrolled)
def get_numpy_parameters(model):
"""Recovers the parameters of a pytorch model in numpy format."""
params = []
for param in model.parameters():
params.append(param)
return stack_torch_tensors(params).detach().numpy()
def exact_hessian(model):
grad_params = torch.autograd.grad(
model.loss, model.parameters(), retain_graph=True, create_graph=True
)
grad_params = stack_torch_tensors(grad_params)
temp = []
for u in range(len(grad_params)):
second_grad = torch.autograd.grad(
grad_params[u], model.parameters(), retain_graph=True
)
temp.append(stack_torch_tensors(second_grad))
Hessian = torch.cat(temp, dim=1)
return Hessian
def exact_hessian_ij(model, loss_ij):
grad_params = torch.autograd.grad(
loss_ij, model.parameters(), retain_graph=True, create_graph=True
)
grad_params = stack_torch_tensors(grad_params)
temp = []
for u in range(len(grad_params)):
second_grad = torch.autograd.grad(
grad_params[u], model.parameters(), retain_graph=True
)
temp.append(stack_torch_tensors(second_grad))
Hessian = torch.cat(temp, dim=1)
return Hessian
def hessian_vector_product(loss, model, v):
"""
Multiplies the Hessians of the loss of a model with respect to its parameters by a vector v.
Adapted from: https://github.com/kohpangwei/influence-release
This function uses a backproplike approach to compute the product between the Hessian
and another vector efficiently, which even works for large Hessians with O(p) complexity for p parameters.
Arguments:
loss: scalar/tensor, for example the output of the loss function
rnn: the model for which the Hessian of the loss is evaluated
v: list of torch tensors, rnn.parameters(),
will be multiplied with the Hessian
Returns:
return_grads: list of torch tensors, contains product of Hessian and v.
"""
# First backprop
first_grads = stack_torch_tensors(
torch.autograd.grad(
loss, model.parameters(), retain_graph=True, create_graph=True
)
)
"""
# Elementwise products
elemwise_products = 0
for grad_elem, v_elem in zip(first_grads, v):
elemwise_products += torch.sum(grad_elem * v_elem)
"""
elemwise_products = torch.mm(
first_grads.view(-1, first_grads.shape[0]).float(),
v[0].view(first_grads.shape[0], -1).float(),
)
# Second backprop
HVP_ = torch.autograd.grad(elemwise_products, model.parameters(), create_graph=True)
return HVP_
def perturb_model_(model, perturb):
"""
Perturbs the parameters of a model by a given vector of influences
Arguments:
model: a pytorch model with p parameters
perturb: a tensors with size p designating the desired parameter-wise perturbation
Returns:
perturbed_model : a copy of the original model with perturbed parameters
"""
params = []
for param in model.parameters():
params.append(param.clone())
param_ = stack_torch_tensors(params)
new_param_ = param_ - perturb
# copy all model attributes
perturbed_model = type(model)()
new_model_dict = dict.fromkeys(model.__dict__.keys())
new_model_state = collections.OrderedDict.fromkeys(model.state_dict().keys())
for key in new_model_dict.keys():
if type(model.__dict__[key]) is torch.Tensor:
new_model_dict[key] = model.__dict__[key].clone()
else:
new_model_dict[key] = copy.deepcopy(model.__dict__[key])
for key in new_model_state.keys():
if type(model.state_dict()[key]) == torch.Tensor:
new_model_state[key] = model.state_dict()[key].clone()
else:
new_model_state[key] = copy.deepcopy(model.state_dict()[key])
perturbed_model.__dict__.update(new_model_dict)
perturbed_model.load_state_dict(new_model_state)
index = 0
for param in perturbed_model.parameters():
if len(param.data.shape) > 1:
new_size = np.max((1, param.data.shape[0])) * np.max(
(1, param.data.shape[1])
)
param.data = new_param_[index : index + new_size].view(
param.data.shape[0], param.data.shape[1]
)
else:
new_size = param.data.shape[0]
param.data = np.squeeze(new_param_[index : index + new_size])
index += new_size
return perturbed_model