def __init__(self, data, args_params): self.data = data.clone() self.full_graph = data.clone() self.num_nodes = self.data.x.size()[0] self.num_edges = ( self.data.edge_index_train[0].shape[0] if hasattr(self.data, "edge_index_train") else self.data.edge_index[0].shape[0] )
def get_batch(self): def get_rpn_testbatch(roidbs, cfg): data = [] label = {} im_info = [] blobs = get_minibatch(roidbs, self._num_classes) data = torch.from_numpy(blobs['data']) im_info = torch.from_numpy(blobs['im_info']) data_height, data_width = data.size(1), data.size(2) data = data.permute(0, 3, 1, 2).contiguous().view(3, data_height, data_width) im_info = im_info.view(3) gt_boxes = torch.FloatTensor([1, 1, 1, 1, 1]) num_boxes = 0 return data, label, im_info, gt_boxes, num_boxes # self.cur_roidb_index = index cur_roidb = self._roidb[self.cur_roidb_index].copy() cur_roidb['image'] = cur_roidb['pattern'] % self.cur_frameid self.cur_seg_len = cur_roidb['frame_seg_len'] # print('frame_seg_len', cur_roidb['frame_seg_len'], 'image path', cur_roidb['image']) data, label, im_info, gt_boxes, num_boxes = get_rpn_testbatch( [cur_roidb], self.cfg) if self.key_frameid == self.cur_frameid: # key frame # self.data_key = data[0]['data'].copy() self.data_key = data.clone() if self.key_frameid == 0: self.key_frame_flag = 0 else: self.key_frame_flag = 1 else: self.key_frame_flag = 2 # extend_data = [{'data': data[0]['data'], # 'im_info': data[0]['im_info'], extend_data = [{ 'data': data, 'im_info': im_info, 'gt_boxes': gt_boxes, 'num_boxes': num_boxes, 'data_key': self.data_key, 'feat_key': torch.from_numpy(np.zeros( (1, self.cfg.network.APN_FEAT_DIM, 1, 1))) }] # print('len(data)', len(data)) # self.data = [[extend_data[i][name] for name in self.data_name] for i in range(len(data))] self.data = [{name: extend_data[i][name] for name in self.data_name} for i in range(1)] self.im_info = im_info
def poison(data, mode='train'): black = -1 white = 1 if TARGET_DATASET_NAME == 'gtsrb': black = (1 - 0.31) / 0.28 white = (-1 - 0.31) / 0.28 poison_data = data.clone() for j in range(data.shape[0]): for a in range(args.d): for b in range(args.d): if (a + b) % 2 == 1: poison_data[j, 25 + a, 25 + b] = white elif (a + b) % 2 == 0: poison_data[j, 25 + a, 25 + b] = black # print(data.shape) # print(poison_data.shape) ''' # if args.p and args.s: # _data = torch.cat((data, poison_data), dim=0) # _label = torch.cat((label, poison_label), dim=0) # elif (args.p and not args.s) or mode == 'test': # _data = poison_data # _label = poison_label ''' return poison_data
def generate_training_data(data, mask): train_data = data.clone() #train_data = train_data.view(train_data.size(0),-1) #targets = data.view(data.size(0),-1) #pixels = [x for x in range(tdata.size(1)) if not x in pixels_to_fill] #train_data[:, pixels_to_fill]=0 targets = train_data.clone() for i in range(train_data.size(0)): train_data[i, :, :] = train_data[i, :, :] * mask targets = targets.view(train_data.size(0), 1, train_data.size(1), -1) train_data = train_data.view(train_data.size(0), 1, train_data.size(1), -1) # normalization mu = train_data.mean() sigma = train_data.std() def norm_data(x, back=False, getmu=False, getsigma=False): if getmu: return mu if getsigma: return sigma if back: return (x * sigma) + mu else: return (x - mu) / sigma train_data = norm_data(train_data) targets = norm_data(targets) train = torch.utils.data.TensorDataset(train_data, targets) return train, norm_data
def __init__(self, data, args_params): self.data = data.clone() self.full_graph = data.clone() self.num_nodes = self.data.x.size()[0] self.num_edges = (self.data.edge_index_train[0].shape[0] if hasattr( self.data, "edge_index_train") else self.data.edge_index[0].shape[0]) self.gen_adj() self.train_mask = self.data.train_mask.cpu().numpy() self.node_train = np.arange(1, self.num_nodes + 1) * self.train_mask self.node_train = self.node_train[self.node_train != 0] - 1 self.sample_coverage = args_params["sample_coverage"] self.preprocess()
def occludeimg_with_center(data, center): # Randomily choose a center that is on the object # of the image and mask out a 6*6 square around it top, bot, left, right = center occluded = data.clone() occluded[0, top:bot, left:right] = 0.0 return occluded
def masking_noise(data, frac): """ data: Tensor frac: fraction of unit to be masked out """ data_noise = data.clone() rand = torch.rand(data.size()) data_noise[rand < frac] = 0 return data_noise
def cutmix(data, target, alpha): indices = torch.randperm(data.size(0)) shuffled_data = data[indices] # shuffled_target = target[indices] lam = np.clip(np.random.beta(alpha, alpha),0.3,0.4) bbx1, bby1, bbx2, bby2 = rand_bbox(data.size(), lam) new_data = data.clone() new_data[:, :, bby1:bby2, bbx1:bbx2] = data[indices, :, bby1:bby2, bbx1:bbx2] # adjust lambda to exactly match pixel ratio lam = 1 - ((bbx2 - bbx1) * (bby2 - bby1) / (data.size()[-1] * data.size()[-2])) # targets = (target, shuffled_target, lam) return new_data, target
def compute(data): global W, B buffer = data.clone() for i in range(0, len(net_shape)-1): buffer = torch.matmul(buffer, W[i]) + B[i] if net_f[i] != 0: buffer = net_f[i](buffer) result = buffer[:, 0] #result = torch.prod(buffer, dim=1) return result
def occludeimg_and_returncenter(data): # Randomily choose a center that is on the object # of the image and mask out a 6*6 square around it occluded = data.clone() size = occluded.size() nonzeros = torch.nonzero(occluded[0]) choice = random.randint(0, len(nonzeros)-1) row = nonzeros[choice][0] col = nonzeros[choice][1] left = max(0, col-half_occludesize) right = min(27, col+half_occludesize) top = max(0, row-half_occludesize) bot = min(27, row+half_occludesize) occluded[0, top:bot, left:right] = 0.0 return occluded, (top, bot, left, right)
def trans_RGB_bicubic(data): up = args.upscale ims_np = (data.clone()*255.).permute(0, 2, 3, 1).numpy().astype(np.uint8) hr_size = ims_np.shape[1] lr_size = hr_size // up rgb_hrs = data.new().resize_(data.size(0), 3, hr_size, hr_size).zero_() for i, im_np in enumerate(ims_np): im = Image.fromarray(im_np, 'RGB') rgb_lr = Resize((lr_size, lr_size), Image.BICUBIC)(im) rgb_hr = Resize((hr_size, hr_size), Image.BICUBIC)(rgb_lr) rgb_hr = ToTensor()(rgb_hr) rgb_hrs[i].copy_(rgb_hr) return rgb_hrs
def generate_adv_images(model, device, kwargs): model.eval() # forSoftMaxList = torch.cuda.FloatTensor() sfMax = [] targeted_class_labelsList = [] image_namesList = [] maxImages = 10 advImageID = 1 targetList=[] targetDict={} mean = (0.1307,) std = (0.3081,) with torch.enable_grad(): path = 'D:/MComp/CS5260 Deep Learning and NN-2/Assignment_1/Assignment_1/data/' dataLoader = torch.utils.data.DataLoader( torchvision.datasets.DatasetFolder(path, loader=numpy_loader, extensions='.npy', transform=transforms.Compose([transforms.ToTensor(), transforms.Normalize(mean, std)])), batch_size=100, **kwargs) #hardcoding batch size to load the class one by one given_dataset = [] for data1, target1 in dataLoader: data1, target1 = data1.to(device), target1.to(device) if len(given_dataset) ==0: given_dataset = data1.squeeze().detach().cpu().numpy() else: given_dataset = np.concatenate([given_dataset, data1.squeeze().detach().cpu().numpy()], axis=0) epsilon =0.6 iterNum =[60, 100, 50, 84, 50, 70, 70, 82, 50, 60] epsilonarr = [0.81, 0.65, 0.8, 0.6, 0.8, 0.81, 0.8, 0.81, 1.0, 0.81] for i in range(1): adv_images = [] targeted_class_labels = [] image_names = [] print("Epsilon Value: " + str(epsilonarr)) print("Iteration number : " + str(iterNum)) # epsilonarr = np.ones(10) # epsilonarr = epsilonarr * epsilon targetID = 0 totalSoftmaxList = [] maxIndex=[] Sval=0 for labelCount in range(10): # epsilonarr[1]=0.65 # if labelCount == 1: # iterNum=40 adv_imagesList = torch.cuda.FloatTensor() softMaxList = [] for data_f, target_f in dataLoader: data, target = data_f.to(device), target_f.to(device) targetCopy = torch.LongTensor(100,).zero_().to(device) originalLabel = target[0].item() if (originalLabel == labelCount) | (epsilonarr[labelCount] == 0): # targetID+=1 continue data.requires_grad = True targetCopy += targetID for name, param in model.named_parameters(): # print(name, param.requires_grad) param.requires_grad = False maxim = (1.0 - mean[0])/std[0] minim = (0.0 - mean[0])/std[0] def clip(data_tensor, minimum, maximum): return torch.autograd.Variable(torch.clamp(data_tensor, min=minimum, max=maximum), requires_grad=True) # return torch.clamp(data_tensor, min=minimum, max=maximum) def norm_custom(data): data_unnorm = data * std[0] + mean[0] maxim = data_unnorm.max(axis=1)[0].max() minim = data_unnorm.min(axis=1)[0].min() return torch.autograd.Variable((data_unnorm - minim) / (maxim - minim), requires_grad=True) # data_norm = clip(data, minim, maxim) data_norm = torch.autograd.Variable(data.clone(), requires_grad=True) iter = 0 while iter <= iterNum[labelCount]: # print(iter+1, '->', data_norm.requires_grad) model.zero_grad() data_norm.grad = None output = model.forward(data_norm) outSoftMax = F.softmax(output, dim=1) loss = F.cross_entropy(outSoftMax, targetCopy) loss.backward() gradient = data_norm.grad.data.sign() data_norm.data = data_norm.data - epsilonarr[labelCount] * gradient data_norm = clip(data_norm, minim, maxim) ##Cancel comment out for stopping iter if already 10 values above 0.8 # out_max1 = outSoftMax.max(axis=1) # indices1 = out_max1[0].detach().cpu().numpy().argsort() # out_arg_max1 = out_max1[1].cpu().numpy() # idx1 = 99 # image_iter1 = 0 # counter = 0 # while image_iter1 < 5 and idx1 >= 0: # if (out_arg_max1[indices1[idx1].item()].item() == targetCopy[0].item()) & (out_max1[0][indices1[idx1].item()].item() >= 0.8) : # image_iter1 +=1 # idx1-=1 # if (image_iter1 == 3): # print("Iteration stopped for " + str(originalLabel) + " at iter " + str(iter)) # break iter += 1 # data_norm = data.detach().clone().type(torch.cuda.IntTensor).type(torch.cuda.FloatTensor) # data_norm = norm_custom(data) with torch.no_grad(): output = model(data_norm) outSoftMax = F.softmax(output, dim=1) out_max = outSoftMax.max(axis=1) # print(indices) out_arg_max = out_max[1].cpu().numpy() indices = out_max[0].detach().cpu().numpy().argsort() #For finding S Sarray = [] adv_images1 = data_norm.squeeze().detach().cpu().numpy() # labels1 = out_arg_max # label_indices = np.where(labels1 == labelCount)[0] # a_i = adv_images1[label_indices,:,:] a_i = adv_images1 for k in range(len(a_i)): image= a_i[k,:,:] Sarray.append(np.min(np.sqrt(np.sum(np.square(np.subtract(given_dataset, np.tile(np.expand_dims(image, axis=0), [1000,1,1]))),axis=(1,2))))) sSortIndex = np.asarray(Sarray).argsort() sValitem=0 image_iter = 0 idx = 99 while image_iter < 10 and idx >= 0: if out_arg_max[sSortIndex[idx].item()].item() == labelCount: #Assuming the perturbed image wrongly classifies with high prob adv_imagesList = torch.cat([adv_imagesList, data_norm[sSortIndex[idx].item()]], dim=0) softMaxList.append(out_max[0][sSortIndex[idx].item()].item()) # sValitem = sValitem+ Sarray[sSortIndex[idx].item()] # targeted_class_labelsList.append(originalLabel) # image_namesList.append(f'sasi_{image_iter}_{out_arg_max[indices[idx].item()].item()}_{output[indices[idx].item()][out_arg_max[indices[idx].item()].item()].item()}') image_iter +=1 idx -= 1 # print("Sval of " + str(labelCount) + " : " + str(sValitem/len(Sarray))) # # For epsilon adjustment # softmaxIndex = sorted(range(len(softMaxList)), key=softMaxList.__getitem__) # # if(len(softMaxList)>=10): # if softMaxList[softmaxIndex[len(softMaxList)-10]] > 0.8: # epsilonarr[labelCount] = 0 # print("Epsilon stopped for " + str(labelCount)) remove_files_in_dir(os.path.join(os.getcwd(), f'adv_imgs_{labelCount}')) # os.mkdir(f'adv_imgs_{labelCount}') # for idx, img in enumerate(adv_imagesList): # img_t = (img.detach().cpu().numpy() * std[0] + mean[0]) * 255 # im = Image.fromarray(img_t.reshape(28, 28).astype('uint8'), mode='L') # im.save(f'adv_imgs_{labelCount}/i_{idx}_{softMaxList[idx]}.jpg') # pixels = np.array((img * 255).cpu().detach().numpy(), dtype='int') # pixels = pixels.reshape((28, 28)) # plt.imsave( # f'adv_imgs_{labelCount}/sasi_{idx}_{softMaxList[idx]}.jpeg', # pixels) #Sort the image list adn indices adv_imagesList4dim = adv_imagesList[:,None,:, :] with torch.no_grad(): outputAdvList = model(adv_imagesList4dim) outSoftMaxAdvList = F.softmax(outputAdvList, dim=1) outAdvMax = outSoftMaxAdvList.max(axis=1) indicesAdvList = outAdvMax[0].detach().cpu().numpy().argsort() outAdvArgMax = outAdvMax[1].cpu().numpy() for idx, img in enumerate(adv_imagesList): img_t = (img.detach().cpu().numpy() * std[0] + mean[0]) * 255 im = Image.fromarray(img_t.reshape(28, 28).astype('uint8'), mode='L') im.save(f'adv_imgs_{labelCount}/i_{idx}_{outAdvMax[0][idx].item()}_{outAdvArgMax[idx].item()}.jpg') #For finding final 10 based on S score FinalSarray = [] Finaladv_images1 = adv_imagesList4dim.squeeze().detach().cpu().numpy() # labels1 = out_arg_max # label_indices = np.where(labels1 == labelCount)[0] # a_i = adv_images1[label_indices,:,:] Finala_i = Finaladv_images1 for k in range(len(Finala_i)): Finalimage = Finala_i[k, :, :] FinalSarray.append(np.min(np.sqrt( np.sum(np.square(np.subtract(given_dataset, np.tile(np.expand_dims(Finalimage, axis=0), [1000, 1, 1]))), axis=(1, 2))))) FinalsSortIndex = np.asarray(FinalSarray).argsort() image_iter_advlist = 0 idx_advList = len(adv_imagesList4dim)-1 SvalIndividual= 0 while image_iter_advlist < 10 and idx_advList >= 0: if (outAdvArgMax[FinalsSortIndex[idx_advList].item()].item() == labelCount) & (outAdvMax[0][FinalsSortIndex[idx_advList].item()].item() > 0.8): adv_images.append(adv_imagesList4dim[FinalsSortIndex[idx_advList]]) totalSoftmaxList.append(outAdvMax[0][FinalsSortIndex[idx_advList].item()].item()) maxIndex.append(outAdvMax[1][FinalsSortIndex[idx_advList].item()].item()) Sval = Sval + FinalSarray[FinalsSortIndex[idx_advList].item()] SvalIndividual =SvalIndividual + FinalSarray[FinalsSortIndex[idx_advList].item()] # with torch.no_grad(): # sfMax.append((F.softmax(model(adv_imagesList4dim[indicesAdvList[idx_advList]][:,None,:,:]), dim=1)).max(axis=1)[0].item()) # forSoftMaxList = torch.cat([forSoftMaxList, adv_imagesList4dim[indicesAdvList[idx_advList].item()]], dim=0) targeted_class_labels.append(labelCount) image_names.append( f'sasi_{image_iter_advlist}_{outAdvArgMax[FinalsSortIndex[idx_advList].item()].item()}_{outSoftMaxAdvList[FinalsSortIndex[idx_advList].item()][outAdvArgMax[FinalsSortIndex[idx].item()].item()].item()}') image_iter_advlist += 1 idx_advList -= 1 # print("Minimum Softmax of " + str(labelCount) + ":" + str( # min(totalSoftmaxList[10 * labelCount:10 * labelCount + 10]))) # print("Maximum Softmax of " + str(labelCount) + ":" + str( # max(totalSoftmaxList[10 * labelCount:10 * labelCount + 10]))) print(SvalIndividual/10) targetID+=1 # break # print("Done -> "+str(labelCount)) # forSoftMaxList = forSoftMaxList[:,None, :, :] # with torch.no_grad(): # SMoutputAdvList = model(forSoftMaxList) # softMaxValsFinal = F.softmax(SMoutputAdvList, dim=1) # sFmAX = softMaxValsFinal.max(axis=1)[0] print("S Value: " + str(Sval/len(maxIndex))) if len(adv_images) < 100: print("Not enough images generated") iterNum = [i + 1 for i in iterNum] return adv_images,image_names,targeted_class_labels
def generate_hole(data): hdata = data.clone() hdata[250:300, 250:300, 250:300] = -1 #pixels = [i for i, x in enumerate(hdata) if x ==-1] return hdata # {"hdata":hdata, "pixels": pixels}
def evaluate(self): self.model.eval() std_loss = Accumulator('std_loss') adv_loss = Accumulator('adv_loss') std_corr = Accumulator('std_corr') adv_corr = Accumulator('adv_corr') std_logits = Accumulator('std_logits') adv_logits = Accumulator('adv_logits') seen_classes = [] adv_images = Accumulator('adv_images') first_batch_images = Accumulator('first_batch_images') from PIL import Image # for batch_idx, (data, target) in enumerate(self.val_loader[0]): # if self.cuda: # data, target = data.cuda(non_blocking=True), target.cuda(non_blocking=True) # with torch.no_grad(): # #output = self.model(data) # data_cpy = data.clone().detach() # std_cpy = data.clone().detach() # std_cpy is used for finding the standard accuracy and has transforms applied as normal # # data_cpy = torch.tensor([]) # # std_cpy = torch.tensor([]) # # for idx in range(len(data_cpy)): # # #print("Tensor is cuda?", data_cpy.is_cuda) # # # data_cpy = torch.cat((data_cpy, torch.tensor(transforms.functional.normalize(transforms.functional.to_tensor(data[idx, :]), IMAGENET_MEAN, IMAGENET_STD) ))) # # #std_cpy[idx] = transforms.functional.normalize(data[idx].clone().cpu(), IMAGENET_MEAN, IMAGENET_STD).cuda() # DELETE # # transformedTensor = applyTransforms(np.copy(data[idx, :])) # # std_cpy = torch.cat((std_cpy, torch.tensor(transforms.functional.normalize(transformedTensor.clone().cpu(), IMAGENET_MEAN, IMAGENET_STD)))) # # #std_cpy[idx, :] = transforms.functional.normalize(transformedTensor.cpu(), IMAGENET_MEAN, IMAGENET_STD).cuda() # # transformedImage = norm_to_pil_image(np.array(std_cpy[idx, :].cpu())) # # transformedImage.save('sample_data/standard' + str(idx) + '.png') # # untransformedImage = norm_to_pil_image(np.array(data_cpy[idx, :].cpu())) # # untransformedImage.save('sample_data/data' + str(idx) + '.png') # # # print(np.array(data_cpy[idx].cpu()) - np.array(std_cpy[idx].cpu())) # output = self.model(std_cpy) # std_logits.update(output.cpu()) # loss = F.cross_entropy(output, target, reduction='none').cpu() # std_loss.update(loss) # corr = correct(output, target) # corr = corr.view(corr.size()[0]).cpu() # std_corr.update(corr) # # run_output = {'std_loss':std_loss.avg, # 'std_acc':std_corr.avg} # print('Standard Batch', batch_idx) # print(run_output) for batch_idx, (data, target) in enumerate(self.val_loader[1]): # data is normalized at this point if self.cuda: data, target = data.cuda(non_blocking=True), target.cuda( non_blocking=True) # for idx in range(len(data)): # savedImage = norm_to_pil_image(data[idx]) # savedImage.save("sample_data/eric" + str(idx) + '.png') # with torch.no_grad(): # #output = self.model(data) # data_cpy = data.clone().detach() # std_cpy = data.clone().detach() # std_cpy is used for finding the standard accuracy and has transforms applied as normal # # data_cpy = torch.tensor([]) # # std_cpy = torch.tensor([]) # # for idx in range(len(data_cpy)): # # #print("Tensor is cuda?", data_cpy.is_cuda) # # data_cpy = torch.cat((data_cpy, torch.tensor(transforms.functional.normalize(transforms.functional.to_tensor(data[idx, :]), IMAGENET_MEAN, IMAGENET_STD) ))) # # #std_cpy[idx] = transforms.functional.normalize(data[idx].clone().cpu(), IMAGENET_MEAN, IMAGENET_STD).cuda() # DELETE # # transformedTensor = applyTransforms(np.copy(data[idx, :])) # # std_cpy = torch.cat((std_cpy, torch.tensor(transforms.functional.normalize(transformedTensor.clone().cpu(), IMAGENET_MEAN, IMAGENET_STD)))) # # #std_cpy[idx, :] = transforms.functional.normalize(transformedTensor.cpu(), IMAGENET_MEAN, IMAGENET_STD).cuda() # # transformedImage = norm_to_pil_image(np.array(std_cpy[idx, :].cpu())) # # transformedImage.save('sample_data/standard' + str(idx) + '.png') # # untransformedImage = norm_to_pil_image(np.array(data_cpy[idx, :].cpu())) # # untransformedImage.save('sample_data/data' + str(idx) + '.png') # # # print(np.array(data_cpy[idx].cpu()) - np.array(std_cpy[idx].cpu())) # output_adv = self.model(data) # adv_logits.update(output_adv.cpu()) # loss = F.cross_entropy(output_adv, target, reduction='none').cpu() # adv_loss.update(loss) # corr = correct(output_adv, target) # corr = corr.view(corr.size()[0]).cpu() # adv_corr.update(corr) rand_target = torch.randint(0, self.nb_classes - 1, target.size(), dtype=target.dtype, device='cuda') rand_target = torch.remainder(target + rand_target + 1, self.nb_classes) data_cpy = data.clone().detach() for idx in range(len(data_cpy)): # savedImage = norm_to_pil_image(data_adv[idx]) # savedImage.save("sample_data/before_transforms" + str(idx) + '.png') unnormalized = reverse_normalization(data[idx]) changed = np.swapaxes( np.array(unnormalized.cpu().detach()) * 255.0, 0, 2) transformed = applyTransforms( np.swapaxes( np.array(unnormalized.cpu().clone().detach()) * 255.0, 0, 2)) data_cpy[idx] = transforms.functional.normalize( transformed.clone().cpu(), IMAGENET_MEAN, IMAGENET_STD).cuda() #from PIL import Image data_adv = self.attack(self.model, data_cpy, rand_target, avoid_target=False, scale_eps=False) # for idx in range(len(data)): # savedImage = norm_to_pil_image(data_adv[idx]) # savedImage.save("sample_data/eric" + str(idx) + '.png') with torch.no_grad(): output_adv = self.model(data_adv) adv_logits.update(output_adv.cpu()) loss = F.cross_entropy(output_adv, target, reduction='none').cpu() adv_loss.update(loss) corr = correct(output_adv, target) corr = corr.view(corr.size()[0]).cpu() adv_corr.update(corr) run_output = {'adv_loss': adv_loss.avg, 'adv_acc': adv_corr.avg} print('Adv Batch', batch_idx) print(run_output) summary_dict = { 'std_acc': std_corr.avg.item(), 'adv_acc': adv_corr.avg.item() } print(std_loss.avg, std_corr.avg, adv_loss.avg, adv_corr.avg)
def train(model, train_loader, valid_loader, num_epochs=5, learning_rate=1e-4): start_time = time.time() print("Training Started...") torch.manual_seed(42) criterion = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) # Store loss and accuracy in lists for each epoch train_acc, val_acc, train_loss, val_loss = [], [], [], [] for epoch in range(num_epochs): total_train_loss = 0.0 total_val_loss = 0.0 n = 1 i = 1 for data in train_loader: if use_cuda and torch.cuda.is_available(): data = data.cuda() # send data to cuda datam = zero_out_random_feature(data.clone( )) # zero out one categorical feature on a cloned item recon = model(datam) # pass through model loss = criterion(recon, data) # compare ground truth with prediction loss.backward() # back propagation optimizer.step() # update weights optimizer.zero_grad() # zero gradient total_train_loss += loss.item() n = n + 1 # tracking validation loss train_loss.append(total_train_loss / n) for data in valid_loader: if use_cuda and torch.cuda.is_available(): data = data.cuda() # send data to cuda datam = zero_out_random_feature(data.clone( )) # zero out one categorical feature on a cloned item recon = model(datam) # pass through model loss = criterion(recon, data) # compare ground truth with prediction total_val_loss += loss.item() i = i + 1 val_loss.append(total_val_loss / i) # tracking accuracy train_acc.append(get_accuracy(model, train_loader)) val_acc.append(get_accuracy(model, valid_loader)) print(epoch, train_loss[-1], val_loss[-1], train_acc[-1], val_acc[-1]) n = len(train_acc) print('Finished Training') end_time = time.time() elapsed_time = end_time - start_time print("Total time elapsed: {:.2f} seconds".format(elapsed_time)) # plot loss plt.title("Epoch vs Loss") plt.plot(range(0, n), train_loss, label='Train') # plotting the training accuracy plt.plot(range(0, n), val_loss, label='Validation') # plotting the validation accuracy plt.xlabel("Epoch") plt.ylabel("Loss") plt.legend(loc='upper right') plt.show() print("Final Train Loss: {}".format(train_loss[-1])) print("Final Validation Loss: {}".format(val_loss[-1])) # plot accuracy plt.title("Epoch vs Accuracy") plt.plot(range(0, n), train_acc, label='Train') # plotting the training accuracy plt.plot(range(0, n), val_acc, label='Validation') # plotting the validation accuracy plt.xlabel("Epoch") plt.ylabel("Accuracy") plt.legend(loc='lower right') plt.show() print("Final Train Accuracy: {}".format(train_acc[-1])) print("Final Validation Accuracy: {}".format(val_acc[-1]))
def convert_to_binary(data: torch.FloatTensor, threshold=3): rtn = data.clone() rtn[data == 0.] = -1. rtn[[x & y for (x, y) in zip([data > 0.], [data < threshold])]] = 0. rtn[data >= threshold] = 1. return rtn
def __init__(self, data, args_params): self.data = data.clone() self.num_nodes = self.data.x.size()[0] self.num_edges = (self.data.edge_index_train.size()[1] if hasattr( self.data, "edge_index_train") else self.data.edge_index.size()[1])
def reduce_tensor(data, world_size): rt = data.clone() dist.all_reduce(rt, op=dist.ReduceOp.SUM) rt /= world_size return rt
def save_image(filename, data): img = data.clone().clamp(0, 255).numpy() img = img.transpose(1, 2, 0).astype("uint8") img = Image.fromarray(img) img.save(filename)
def main(args): with open("./saved_models/{}/{}/{}/{}/{}".format(args.dataset, args.backbone, args.net, args.mode, args.config)) as f: cfg = yaml.safe_load(f) # ---------------------------------------------Prepare configuration for experiment ------------------------- NET_ARGS = cfg['NET_ARGS'] DATA_ARGS = cfg['DATA_ARGS'] EXP_ARGS = cfg['EXP_ARGS'] attack_dir = DATA_ARGS[ 'attack_test_dir'] if args.split == 'test' else DATA_ARGS[ 'attack_train_dir'] # --------------------------------------------- Prepare the dataset------------------------------------------ attack_dataset = datasets.ImageFolder( attack_dir, transforms.Compose([ transforms.Resize(size=(DATA_ARGS['img_size'], DATA_ARGS['img_size'])), transforms.ToTensor(), ])) data_loader = torch.utils.data.DataLoader( attack_dataset, batch_size=EXP_ARGS['train_push_batch_size'], shuffle=False, num_workers=4, pin_memory=False, sampler=None) total_batches = len(data_loader) # --------------------------------------------- Prepare model ----------------------------------------------- modelpath = './saved_models/{}/{}/{}/{}/{}'.format(args.dataset, args.backbone, args.net, args.mode, args.checkpoint) # (Commented) Load full model instead of state_dict. # But gives error when the code is refactored to merge multiple folders. # Dont use torch.save() with full object in the future. #ppnet = torch.load(modelpath) #torch.save(ppnet.state_dict(), 'model.pth') # ------------------- Construct model and load state_dict -------------------------------------------------- ppnet = model_Proto.construct_PPNet( base_architecture=NET_ARGS['base_architecture'], pretrained=False, img_size=DATA_ARGS['img_size'], prototype_shape=NET_ARGS['prototype_shape'], num_classes=DATA_ARGS['num_classes'], prototype_activation_function=NET_ARGS[ 'prototype_activation_function'], add_on_layers_type=NET_ARGS['add_on_layers_type'], ) ppnet.load_state_dict(torch.load(modelpath)) ppnet_multi = torch.nn.DataParallel(ppnet) ppnet_multi.eval() print("\nModel path is {}".format(modelpath)) correct_fr = 0 correct_att = 0 num_samples = 0 adv_correct_fr = 0 adv_correct_att = 0 criterion = torch.nn.CrossEntropyLoss().cuda() # --------------------------------------------- Prepare attack ---------------------------------------------- attack_params = get_attack_params(args.attack) print( "Attack type: {}, Epsilon: {:.5f}, Alpha: {:.5f}, Iters: {}\n".format( attack_params['TYPE'], attack_params['EPS'], attack_params['ALPHA'], attack_params['ITERS'])) # --------------------------------------------- Run attack -------------------------------------------------- for it, (data, target) in enumerate(data_loader): data, target = data.cuda(), target.cuda() num_samples += data.shape[0] # ------------------------- predictions on clean image -------------------------------------------------- output_fr = ppnet_multi(normalize_fn(data.clone().detach()))[0] pred_fr = output_fr.data.max(1, keepdim=True)[1] correct_fr += pred_fr.eq(target.data.view_as(pred_fr)).cpu().sum() # -------------------------prepare adversarial image------------------------- adv_img = attack_fns_Proto(ppnet_multi, criterion, data, target, eps=attack_params['EPS'], alpha=attack_params['ALPHA'], attack_type=attack_params['TYPE'], iters=attack_params['ITERS'], normalize_fn=normalize_fn) # -------------------------predictions on adversarial image---------------------------------------------- output_adv_fr = ppnet_multi(normalize_fn(adv_img.clone().detach()))[0] pred_adv_fr = output_adv_fr.data.max(1, keepdim=True)[1] adv_correct_fr += torch.sum(output_adv_fr.argmax( dim=-1) == target).item() # -----------------------------Print Stats--------------------------------------------------------------- print("Batch: [{}/{}]\t FR_branch Normal: {:.2f}%\t" "FR_branch Adv: {: .2f}%, ".format( it, total_batches, (100.0 * float(correct_fr) / num_samples), (100.0 * float(adv_correct_fr) / num_samples))) del data, target, output_fr, output_adv_fr print("Final \t FR_branch Normal: {:.2f}%\t" "FR_branch Adv: {:.2f}%\n".format( (100.0 * float(correct_fr) / num_samples), (100.0 * float(adv_correct_fr) / num_samples)))
def evaluate(self): self.model.eval() std_loss = Accumulator('std_loss') adv_loss = Accumulator('adv_loss') std_corr = Accumulator('std_corr') adv_corr = Accumulator('adv_corr') std_logits = Accumulator('std_logits') adv_logits = Accumulator('adv_logits') seen_classes = [] adv_images = Accumulator('adv_images') first_batch_images = Accumulator('first_batch_images') from PIL import Image for batch_idx, (data, target) in enumerate(self.val_loader[0]): if self.cuda: data, target = data.cuda(non_blocking=True), target.cuda( non_blocking=True) with torch.no_grad(): std_cpy = data.clone().detach( ) # std_cpy is used for finding the standard accuracy and has transforms applied as normal output = self.model(std_cpy) std_logits.update(output.cpu()) loss = F.cross_entropy(output, target, reduction='none').cpu() std_loss.update(loss) corr = correct(output, target) corr = corr.view(corr.size()[0]).cpu() std_corr.update(corr) run_output = {'std_loss': std_loss.avg, 'std_acc': std_corr.avg} print('Standard Batch', batch_idx) print(run_output) for batch_idx, (data, target) in enumerate(self.val_loader[1]): # data is normalized at this point if self.cuda: data, target = data.cuda(non_blocking=True), target.cuda( non_blocking=True) rand_target = torch.randint(0, self.nb_classes - 1, target.size(), dtype=target.dtype, device='cuda') rand_target = torch.remainder(target + rand_target + 1, self.nb_classes) data_cpy = data.clone().detach() for idx in range(len(data_cpy)): unnormalized = reverse_normalization(data[idx]) changed = np.swapaxes( np.array(unnormalized.cpu().detach()) * 255.0, 0, 2) transformed = applyTransforms( np.swapaxes( np.array(unnormalized.cpu().clone().detach()) * 255.0, 0, 2)) data_cpy[idx] = transforms.functional.normalize( transformed.clone().cpu(), IMAGENET_MEAN, IMAGENET_STD).cuda() data_adv = self.attack(self.model, data_cpy, rand_target, avoid_target=False, scale_eps=False) with torch.no_grad(): output_adv = self.model(data_adv) adv_logits.update(output_adv.cpu()) loss = F.cross_entropy(output_adv, target, reduction='none').cpu() adv_loss.update(loss) corr = correct(output_adv, target) corr = corr.view(corr.size()[0]).cpu() adv_corr.update(corr) run_output = {'adv_loss': adv_loss.avg, 'adv_acc': adv_corr.avg} print('Adv Batch', batch_idx) print(run_output) summary_dict = { 'std_acc': std_corr.avg.item(), 'adv_acc': adv_corr.avg.item() } print(std_loss.avg, std_corr.avg, adv_loss.avg, adv_corr.avg)
def evaluate(self): self.model.eval() std_loss = Accumulator('std_loss') adv_loss = Accumulator('adv_loss') std_corr = Accumulator('std_corr') adv_corr = Accumulator('adv_corr') std_logits = Accumulator('std_logits') adv_logits = Accumulator('adv_logits') seen_classes = [] adv_images = Accumulator('adv_images') first_batch_images = Accumulator('first_batch_images') from PIL import Image for batch_idx, (data, target) in enumerate(self.val_loader[0]): if self.cuda: data, target = data.cuda(non_blocking=True), target.cuda(non_blocking=True) with torch.no_grad(): std_cpy = data.clone().detach() output = self.model(std_cpy) std_logits.update(output.cpu()) loss = F.cross_entropy(output, target, reduction='none').cpu() std_loss.update(loss) corr = correct(output, target) corr = corr.view(corr.size()[0]).cpu() std_corr.update(corr) run_output = {'std_loss':std_loss.avg, 'std_acc':std_corr.avg} print('Standard Batch', batch_idx) print(run_output) for batch_idx, (data, target) in enumerate(self.val_loader[1]): # data is normalized at this point if self.cuda: data, target = data.cuda(non_blocking=True), target.cuda(non_blocking=True) rand_target = torch.randint( 0, self.nb_classes - 1, target.size(), dtype=target.dtype, device='cuda') rand_target = torch.remainder(target + rand_target + 1, self.nb_classes) from PIL import Image data_adv = self.attack(self.model, data, rand_target, avoid_target=False, scale_eps=False) with torch.no_grad(): output_adv = self.model(data_adv) adv_logits.update(output_adv.cpu()) loss = F.cross_entropy(output_adv, target, reduction='none').cpu() adv_loss.update(loss) corr = correct(output_adv, target) corr = corr.view(corr.size()[0]).cpu() adv_corr.update(corr) run_output = {'adv_loss':adv_loss.avg, 'adv_acc':adv_corr.avg} print('Adv Batch', batch_idx) print(run_output) summary_dict = {'std_acc':std_corr.avg.item(), 'adv_acc':adv_corr.avg.item()} print(std_loss.avg, std_corr.avg, adv_loss.avg, adv_corr.avg)
def run_experiment(netG, dataloader_test, nn_path, opt, optimize_red_first=False, n_bfgs_iter=50, lbfgs_lr=0.05, num_lbfgs_trials=3): """ Optimize over the latent noise to try to reconstruct a target image. """ # read the training set to get images for nearest neighbors search_images, search_image_names = nearest_neighbors.read_search_images( search_dataset=nn_path, classes_of_interest=opt.class_names, num_channels=opt.original_nc, use_cuda=opt.cuda) # prepare data loader data_looper = GanImageloader() iterator_data = data_looper.return_iterator(dataloader_test, opt.cuda, opt.nc, return_labels=False, num_passes=1) # the generator in the eval mode netG.eval() # create folders for cl in opt.class_names: os.system('mkdir -p {0}'.format(os.path.join(opt.experiment, cl))) l2_dists = {cl: [] for cl in opt.class_names} lls_noise = {cl: [] for cl in opt.class_names} lls_noise_init = {cl: [] for cl in opt.class_names} nn_dists = {cl: [] for cl in opt.class_names} #first arg = mean, secondarg = cov mvn = multivariate_normal(np.zeros(opt.nz), np.identity(opt.nz)) def compute_rec_error(data, rec): rec_error = data - rec l2_dist = torch.sum(rec_error**2 / rec_error.numel())**0.5 return l2_dist def im_to_01(im): return im * opt.std_val + opt.mean_val def im_to_original(im): return (im - opt.mean_val) / opt.std_val for i_batch, data in enumerate(iterator_data): print('Batch {}'.format(i_batch)) class_name = 'neutrophils' netG_forward = lambda input: netG(input) reconstructions_best = data.clone() reconstructions_best.data.zero_() reconstructions_best_init = data.clone() reconstructions_best_init.data.zero_() reconstructions_error_best = [float('inf')] * data.size(0) ll_noise_best = [float('inf')] * data.size(0) ll_noise_init_best = [float('inf')] * data.size(0) nn_dists_batch = [float('inf')] * data.size(0) for i_trial in range(num_lbfgs_trials): print('Class {0}: {1}, trial {2} of {3}'.format( 1, 'neutrophils', i_trial + 1, num_lbfgs_trials)) sys.stdout.flush() # get the noise leading to the good reconstruction if optimize_red_first: noise_init, noise = reconstruct_cells_red_first( data, netG_forward, opt, n_bfgs_iter=n_bfgs_iter, lbfgs_lr=lbfgs_lr) else: print('Optimize red first else') noise_init, noise = reconstruct_cells(data, netG_forward, opt, n_bfgs_iter=n_bfgs_iter, lbfgs_lr=lbfgs_lr) # get reconstructions reconstructions_init = netG_forward(noise_init) reconstructions = netG_forward(noise) # compute reconstruction errors for i_im in range(reconstructions.size(0)): # get log-likelihoods noise_np = noise[i_im].view(-1).data.cpu().numpy() ll_noise = -mvn.logpdf(noise_np) noise_init_np = noise_init[i_im].view(-1).data.cpu().numpy() ll_noise_init = -mvn.logpdf(noise_init_np) l2_dist = compute_rec_error( im_to_01(data[i_im].data), im_to_01(reconstructions[i_im].data)) if l2_dist < reconstructions_error_best[i_im]: reconstructions_error_best[i_im] = l2_dist reconstructions_best[i_im] = reconstructions[i_im] reconstructions_best_init[i_im] = reconstructions_init[ i_im] ll_noise_best[i_im] = ll_noise ll_noise_init_best[i_im] = ll_noise_init # find nearest neighbors from the training set neighbors = torch.FloatTensor(reconstructions_best.size()) if opt.cuda: neighbors = neighbors.cuda() for i_im in range(reconstructions_best.size(0)): ref_im = data[i_im].data ref_im_01 = im_to_01(ref_im) _, nn_ids = nearest_neighbors.find_neighbors( ref_im_01, search_images['neutrophils'], search_image_names['neutrophils'], num_neighbors=1) nn_im_01 = search_images['neutrophils'][nn_ids[0]] neighbors[i_im] = im_to_original(nn_im_01) nn_dists_batch[i_im] = compute_rec_error(nn_im_01, ref_im_01) neighbors = Variable(neighbors) # save results for i_im in range(reconstructions_best.size(0)): all_images = [ data[i_im], reconstructions_best[i_im], reconstructions_best_init[i_im], neighbors[i_im] ] all_images = torch.stack(all_images, 0) all_images = pad_channels(all_images.data, 1) file_name = os.path.join( opt.experiment, 'neutrophils', '{0}_batch{1}_image{2}.png'.format(class_name, i_batch, i_im)) vutils.save_image(im_to_01(all_images), file_name) l2_dist = reconstructions_error_best[i_im] ll_noise = ll_noise_best[i_im] ll_noise_init = ll_noise_init_best[i_im] l2_dists[class_name].append(l2_dist) lls_noise[class_name].append(ll_noise) lls_noise_init[class_name].append(ll_noise_init) nn_dists[class_name].append(nn_dists_batch[i_im]) # saving the full reconstruction data all_data = { 'l2_dists': l2_dists, 'lls_noise': lls_noise, 'lls_noise_init': lls_noise_init, 'nn_dists': nn_dists } print('Saving pth....') torch.save(all_data, os.path.join(opt.experiment, 'reconstruction_data.pth')) # print aggregated statistics for i_class, class_name in enumerate(opt.class_names): l2 = np.array(l2_dists[class_name]) l2_mean = np.mean(l2) l2_std = np.std(l2) ll_noise = np.array(lls_noise[class_name]) ll_noise_mean = np.mean(ll_noise) ll_noise_std = np.std(ll_noise) ll_noise_init = np.array(lls_noise_init[class_name]) ll_noise_init_mean = np.mean(ll_noise_init) ll_noise_init_std = np.std(ll_noise_init) nn_d = np.array(nn_dists[class_name]) nn_d_mean = np.mean(nn_d) nn_d_std = np.std(nn_d) print( 'Class {0}: L2-reconstr mean {1:0.3f} std {2:0.3f}; L2-noise mean {3:0.3f} std {4:0.3f}; L2-noise-init mean {5:0.3f} std {6:0.3f}; NN dist {7:0.3f} std {8:0.3f}' .format(class_name, l2_mean, l2_std, ll_noise_mean, ll_noise_std, ll_noise_init_mean, ll_noise_init_std, nn_d_mean, nn_d_std)) l2 = np.concatenate([np.array(d) for d in l2_dists.values()]) l2_mean = np.mean(l2) l2_std = np.std(l2) ll_noise = np.concatenate([np.array(d) for d in lls_noise.values()]) ll_noise_mean = np.mean(ll_noise) ll_noise_std = np.std(ll_noise) ll_noise_init = np.concatenate( [np.array(d) for d in lls_noise_init.values()]) ll_noise_init_mean = np.mean(ll_noise_init) ll_noise_init_std = np.std(ll_noise_init) nn_d = np.concatenate([np.array(d) for d in nn_dists.values()]) nn_d_mean = np.mean(nn_d) nn_d_std = np.std(nn_d) print( 'All classes: L2-reconstr mean {0:0.3f} std {1:0.3f}; L2-noise mean {2:0.3f} std {3:0.3f}; L2-noise-init mean {4:0.3f} std {5:0.3f}; NN dist {6:0.3f} std {7:0.3f}' .format(l2_mean, l2_std, ll_noise_mean, ll_noise_std, ll_noise_init_mean, ll_noise_init_std, nn_d_mean, nn_d_std))
def __init__(self, data, args_params): self.data = data.clone() self.num_nodes = self.data.x.size()[0] self.num_edges = self.data.edge_index.size()[1]
def __getitem__(self, idx): if idx == 0 and self.fixed_batch: printc.red('FIXED BATCH:', self.fixed_batch) if self.fixed_batch: idx = 0 if idx >= len(self.ds_idx_seq): for iter in set(self.iters): # dataloaders iter.__del__() raise StopIteration ds_idx = self.ds_idx_seq[idx] if self.args.combine in ['inbatch']: ### destroy this later? if idx * len(self.datasets) >= len(self.ds_idx_seq): for iter in set(self.iters): # dataloaders iter.__del__() raise StopIteration aux = [] for l in self.iters: sample = next(l) aux += [sample] info = {} info['labels'] = torch.cat([c['labels'] for c in aux]) data = torch.cat([c['data'] for c in aux]).float().cuda() return data, info info = {} loader = self.loaders[ds_idx] sample = next(self.iters[ds_idx]) info['loader'] = 'other' if isinstance(self.loaders[ds_idx].ds_info['dataset'], DS_AMOS): # only AMOS provides info if hasattr(loader, 'block_sizes'): info['block_sizes'] = loader.block_sizes[0] loader.block_sizes = loader.block_sizes[1:] info['PS_idxs'] = sample['PS_idxs'] info['set_idxs'] = sample['set_idxs'] info['loader'] = 'AMOS' info['sigmas'] = self.sigmas[ds_idx][info['PS_idxs']] info['labels'] = sample['labels'] info['ds_idx'] = ds_idx data = sample['data'].float().cuda() if self.args.duplicates > 0: dups = self.args.duplicates info['labels'] = None dup_data = data[-2 * dups:] data = torch.cat([data, dup_data]) if self.args.antiaug: info['labels'] = None if not hasattr(self, 'antiaug_tr_pad'): self.antiaug_tr_pad = nn.Sequential( torch.nn.ReplicationPad2d(20)).cuda() if not hasattr(self, 'antiaug_tr_crop'): self.antiaug_tr_crop = nn.Sequential( kornia.augmentation.CenterCrop(64)).cuda() data_ = data.clone() data_ = self.antiaug_tr_pad(data_) As = data_[0::2] Ps = data_[1::2] B, CH, H, W = As.shape aff_dict = KF.rg.random_affine_generator(B, H, W, degrees=(0.0, 0.0), translate=(0.03, 0.03), scale=(1.0, 1.0), shear=(0.0, 0.0), same_on_batch=False) aff_params = {} for k, v in aff_dict.items(): aff_params[k] = v if k == 'translate': aff_params[k] = v.to( v.device) + 0.03 * torch.sign(v).to(v.device) antips = torch.zeros(*data_.shape).cuda() antips[0::2] = KF.apply_affine(As, aff_params) antips[1::2] = KF.apply_affine(Ps, aff_params) antips = self.antiaug_tr_crop(antips) data = torch.cat([data, antips]) if self.args.K: data = {'data': data, 'loader': info['loader']} return data, info
def train(model, train_loader, valid_loader, num_epochs=5, learning_rate=1e-4): """ Training loop. You should update this.""" torch.manual_seed(42) criterion = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) train_acc, val_acc, epochs, val_loss, train_loss = [], [], [], [], [] for epoch in range(num_epochs): val = 0 total_loss=0 for data in train_loader: datam = zero_out_random_feature(data.clone()) # zero out one categorical feature recon = model(datam) loss = criterion(recon, data) loss.backward() optimizer.step() optimizer.zero_grad() total_loss += loss.item() val +=1 train_loss.append(float(total_loss) / (val + 1)) trainacc = get_accuracy(model, train_loader) validacc = get_accuracy(model, valid_loader) print("training acc: ", trainacc) print("validation acc: ", validacc) train_acc.append(trainacc) val_acc.append(validacc) epochs.append(epoch) val = 0 total_loss=0 for data in valid_loader: datam = zero_out_random_feature(data.clone()) # zero out one categorical feature recon = model(datam) loss = criterion(recon, data) total_loss += loss.item() val +=1 val_loss.append(float(total_loss) / (val + 1)) plt.title("Training Accuracy") plt.plot(epochs, train_acc, label="Train") plt.xlabel("epoch") plt.ylabel("Training Accuracy") plt.show() plt.title("Validation Accuracy") plt.plot(epochs, train_acc, label="Validation") plt.xlabel("epoch") plt.ylabel("Validation Accuracy") plt.show() # #Plotting Loss plt.title("Train vs Validation Loss") plt.plot(epochs, train_loss, label="Train") plt.plot(epochs, val_loss, label="Validation") plt.xlabel("Epoch") plt.ylabel("Loss") plt.legend(loc='best') plt.show()