def get_confidences()

in attacks/privacy_attacks.py [0:0]

• 79 lines of code
• 21 McCabe index (conditional complexity)

def get_confidences(params):
    """
    return uncalibrated confidences. 
    """
    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")

    device = torch.device('cpu')

    #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=device)
    private_model.load_state_dict(state_dict_private['model'])
    private_model=private_model.cpu()

    #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)
    
    if params.aug:
        train_confidences=np.zeros(len(hidden_masks['private']['train']))
        heldout_confidences=np.zeros(len(hidden_masks['private']['train']))
        train_summed_confs=[[0] for i in np.arange(len(hidden_masks['private']['train']))]
        heldout_summed_confs=[[0] for i in np.arange(len(hidden_masks['private']['train']))]
        for j in np.arange(10):
            print('Aug', j)
            train_images=torch.stack([dataset[i][0] for i in private_train_ids])
            train_images=train_images.cpu()
            
            heldout_images=torch.stack([dataset[i][0] for i in private_heldout_ids])
            heldout_images=heldout_images.cpu()

            log_softmax = torch.nn.LogSoftmax(dim=1)
        
            train_output=private_model(train_images)
            heldout_output=private_model(heldout_images)
            
            log_train_output=log_softmax(train_output)
            log_heldout_output=log_softmax(heldout_output)
            
            train_confs,_=torch.max(log_train_output,dim=1)
            heldout_confs,_=torch.max(log_heldout_output,dim=1)

            train_confs=train_confs.cpu().detach().numpy()
            heldout_confs=heldout_confs.cpu().detach().numpy()

            for i,id in enumerate(private_train_ids):
                train_summed_confs[id].append(train_confs[i])
            for i,id in enumerate(private_heldout_ids):
                heldout_summed_confs[id].append(heldout_confs[i])
        for id in private_train_ids:
            if params.aug_style=='mean':
                train_confidences[id]=np.mean(train_summed_confs[id][1:])
            elif params.aug_style=='max':
                train_confidences[id]=np.max(train_summed_confs[id][1:])
            elif params.aug_style=='median':
                train_confidences[id]=np.median(train_summed_confs[id][1:])
            elif params.aug_style=='std':
                train_confidences[id]=np.std(train_summed_confs[id][1:])
        for id in private_heldout_ids:
            if params.aug_style=='mean':
                heldout_confidences[id]=np.mean(heldout_summed_confs[id][1:])
            elif params.aug_style=='max':
                heldout_confidences[id]=np.max(heldout_summed_confs[id][1:])
            elif params.aug_style=='median':
                heldout_confidences[id]=np.median(heldout_summed_confs[id][1:])
            elif params.aug_style=='std':
                heldout_confidences[id]=np.std(heldout_summed_confs[id][1:])
        
        train_confidences=train_confidences[private_train_ids]
        heldout_confidences=heldout_confidences[private_heldout_ids]

    else:
        train_confidences=[]
        heldout_confidences=[]

        train_images=torch.stack([dataset[i][0] for i in private_train_ids])
        train_images=train_images.cpu()
        
        heldout_images=torch.stack([dataset[i][0] for i in private_heldout_ids])
        heldout_images=heldout_images.cpu()
        
        log_softmax = torch.nn.LogSoftmax(dim=1)
        
        train_output=private_model(train_images)
        heldout_output=private_model(heldout_images)
        
        log_train_output=log_softmax(train_output)
        log_heldout_output=log_softmax(heldout_output)
        
        train_confidences,_=torch.max(log_train_output,dim=1)
        heldout_confidences,_=torch.max(log_heldout_output,dim=1)
        train_confidences=train_confidences.cpu().detach().numpy()
        heldout_confidences=heldout_confidences.cpu().detach().numpy()
    return train_confidences,heldout_confidences