def get_losses()

in attacks/privacy_attacks.py [0:0]

• 45 lines of code
• 8 McCabe index (conditional complexity)

def get_losses(params):
    """
    return uncalibrated losses. 
    """
    known_masks, hidden_masks = {}, {}
    hidden_masks['public'], hidden_masks['private']={},{}
    known_masks['public'] = torch.load(params.mask_path + "public.pth")
    known_masks['private'] = torch.load( params.mask_path + "private.pth")
    hidden_masks['private']['train']=torch.load( params.mask_path + "hidden/train.pth")
    hidden_masks['private']['heldout'] = torch.load( params.mask_path + "hidden/heldout.pth")
    hidden_masks['public']['train']=torch.load( params.mask_path + "hidden/public_train.pth")
    hidden_masks['public']['heldout'] = torch.load( params.mask_path + "hidden/public_heldout.pth")

    #get the final model parameters
    private_model=build_model(params)
    private_model_path = os.path.join(params.model_path, "checkpoint.pth")
    state_dict_private = torch.load(private_model_path,map_location='cuda:0')
    if params.dataset=='imagenet':
        new_state_dict = OrderedDict()
        for k, v in state_dict_private["model"].items():
            if k[:7]=='module.': # remove `module.`
                new_state_dict[k[7:]] = v
            else:
                new_state_dict[k]=v
        private_model.load_state_dict(new_state_dict)
    else:
        private_model.load_state_dict(state_dict_private['model'])
    private_model=private_model.cuda()

    #get the appropriate ids to dot product
    private_train_ids=(hidden_masks['private']['train']==True).nonzero().flatten().numpy()
    private_heldout_ids=(hidden_masks['private']['heldout']==True).nonzero().flatten().numpy()
    #load the dataset
    dataset = get_dataset(params)
    #initialize dot products to 0
    train_losses=[]
    heldout_losses=[]

    for id in private_train_ids:
        #load each image and target
        image = dataset[id][0].unsqueeze(0)
        image = image.cuda(non_blocking=True)
        target = torch.tensor(dataset[id][1]).unsqueeze(0)
        target = target.cuda(non_blocking=True)

        #get the loss
        output=private_model(image)
        loss=F.cross_entropy(output, target).item()
        train_losses.append(loss)
    
    for id in private_heldout_ids:
        #load each image and target
        image = dataset[id][0].unsqueeze(0)
        image = image.cuda(non_blocking=True)
        target = torch.tensor(dataset[id][1]).unsqueeze(0)
        target = target.cuda(non_blocking=True)

        #get the loss
        output=private_model(image)
        loss=F.cross_entropy(output, target).item()
        heldout_losses.append(loss)
    return train_losses,heldout_losses