def attack(self, model, xo, untargeted, target, w, loss_function=ai.stdLoss, **kargs): w = self.epsilon.getVal(c = w, **kargs) x = nn.Parameter(xo.clone(), requires_grad=True) gradorg = h.zeros(x.shape) is_eq = 1 w = h.ones(x.shape) * w for i in range(self.k): if self.restart is not None and i % int(self.k / self.restart) == 0: x = is_eq * (torch.rand_like(xo) * w + xo) + (1 - is_eq) * x x = nn.Parameter(x, requires_grad = True) model.optimizer.zero_grad() out = model(x).vanillaTensorPart() loss = loss_function(out, target) loss.sum().backward(retain_graph=True) with torch.no_grad(): oth = x.grad / torch.norm(x.grad, p=1) gradorg *= self.mu gradorg += oth grad = (self.r * w / self.k) * ai.mysign(gradorg) if self.should_end: is_eq = ai.mulIfEq(grad, out, target) x = (x + grad * is_eq) if untargeted else (x - grad * is_eq) x = xo + torch.min(torch.max(x - xo, -w),w) x.requires_grad_() model.optimizer.zero_grad() return x
def box(original, diameter): """ This version of it takes advantage of betas being uncorrelated. Unfortunately they stay uncorrelated forever. Counterintuitively, tests show more accuracy - this is because the other box creates lots of 0 errors which get accounted for by the calcultion of the newhead in relu which is apparently worse than not accounting for errors. """ return Box(original, h.ones(original.size()) * diameter, None).checkSizes()
def box(self, original, w, **kargs): """ This version of it takes advantage of betas being uncorrelated. Unfortunately they stay uncorrelated forever. Counterintuitively, tests show more accuracy - this is because the other box creates lots of 0 errors which get accounted for by the calcultion of the newhead in relu which is apparently worse than not accounting for errors. """ radius = self.w.getVal(c = w, **kargs) return self.domain(original, h.ones(original.size()) * radius, None).checkSizes()
def stochasticCorrelate(self, num_correlate, choices=None): if num_correlate == 0: return self domshape = self.head.shape batch_size = domshape[0] num_pixs = h.product(domshape[1:]) num_correlate = min(num_correlate, num_pixs) ucc_mask = h.ones([batch_size, num_pixs]).long() cc_indx_batch_beta = h.cudify( torch.multinomial( ucc_mask.to_dtype(), num_correlate, replacement=False)) if choices is None else choices return self.correlate(cc_indx_batch_beta)
def stochasticDecorrelate(self, num_decorrelate, choices=None, num_to_keep=False): dummy = self.dummyDecorrelate(num_decorrelate) if dummy is not None: return dummy num_error_terms = self.errors.shape[0] batch_size = self.head.shape[0] ucc_mask = h.ones([batch_size, self.errors.shape[0]]).long() cc_indx_batch_err = h.cudify( torch.multinomial( ucc_mask.to_dtype(), num_decorrelate if num_to_keep else num_error_terms - num_decorrelate, replacement=False)) if choices is None else choices return self.decorrelate(cc_indx_batch_err)
def forward(self, x, time=0, **kargs): if self.training: with torch.no_grad(): p = self.p.getVal(time=time) mask = (F.dropout2d if self.use_2d else F.dropout)( h.ones(x.size()), p=p, training=True) if self.alpha_dropout: with torch.no_grad(): keep_prob = 1 - p alpha = -1.7580993408473766 a = math.pow( keep_prob + alpha * alpha * keep_prob * (1 - keep_prob), -0.5) b = -a * alpha * (1 - keep_prob) mask = mask * a return x * mask + b else: return x * mask else: return x
def softplus(self): if self.errors is None: if self.beta is None: return self.new(F.softplus(self.head), None, None) tp = F.softplus(self.head + self.beta) bt = F.softplus(self.head - self.beta) return self.new((tp + bt) / 2, (tp - bt) / 2, None) errors = self.concreteErrors() o = h.ones(self.head.size()) def sp(hd): return F.softplus( hd) # torch.log(o + torch.exp(hd)) # not very stable def spp(hd): ehd = torch.exp(hd) return ehd.div(ehd + o) def sppp(hd): ehd = torch.exp(hd) md = ehd + o return ehd.div(md.mul(md)) fa = sp(self.head) fpa = spp(self.head) a = self.head k = torch.sum(errors.abs(), 0) def evalG(r): return r.mul(r).mul(sppp(a + r)) m = torch.max(evalG(h.zeros(k.size())), torch.max(evalG(k), evalG(-k))) m = h.ifThenElse(a.abs().lt(k), torch.max(m, torch.max(evalG(a), evalG(-a))), m) m /= 2 return self.new(fa, m if self.beta is None else m + self.beta.mul(fpa), None if self.errors is None else self.errors.mul(fpa))
def calcData(data, target): box = m.model.boxSpec(data, target)[0] with torch.no_grad(): if m.model.ty in POINT_DOMAINS: preder = m.model(box[0]).data pred = preder.max( 1, keepdim=True )[1] # get the index of the max log-probability org = m.model(data).max(1, keepdim=True)[1] stat.proved += float(org.eq(pred).sum()) stat.safe += float( pred.eq(target.data.view_as(pred)).sum()) else: bs = m.model(box[1]) stat.width += m.model.widthL(bs).data[ 0] # sum up batch loss stat.safe += m.model.isSafeDom( bs, target).sum().item() stat.proved += sum([ m.model.isSafeDom(bs, (h.ones(target.size()) * n).long()).sum().item() for n in range(num_classes) ])
def line(self, o1, o2, w=0, **kargs): if not self.w is None: w = self.w return self.Domain((o1 + o2) / 2, ((o2 - o1) / 2).abs() + h.ones(o2.size()) * w, None).checkSizes()
def line(self, o1, o2, **kargs): w = self.w.getVal(c = 0, **kargs) return self.domain((o1 + o2) / 2, ((o2 - o1) / 2).abs() + h.ones(o2.size()) * w, None).checkSizes()
def lineSpec(self, x, target): eps = h.ones(x.size()) * self.w return [(x, self.ty.line(x - eps, x + eps, None), target)]