def get_condition(self, z_inp, z_out, x_batches, y_batches):
z_out = transform_network_output(z_out, self.network_output)[0]
targets = y_batches[0]
rules = []
rules.append(
dl2.Implication(
dl2.BoolConst(targets == I['car']),
dl2.GEQ(z_out[:, I['truck']],
z_out[:, I['dog']] + self.margin)))
rules.append(
dl2.Implication(
dl2.BoolConst(targets == I['deer']),
dl2.GEQ(z_out[:, I['horse']],
z_out[:, I['ship']] + self.margin)))
rules.append(
dl2.Implication(
dl2.BoolConst(targets == I['plane']),
dl2.GEQ(z_out[:, I['ship']],
z_out[:, I['frog']] + self.margin)))
rules.append(
dl2.Implication(
dl2.BoolConst(targets == I['dog']),
dl2.GEQ(z_out[:, I['cat']],
z_out[:, I['truck']] + self.margin)))
rules.append(
dl2.Implication(
dl2.BoolConst(targets == I['cat']),
dl2.GEQ(z_out[:, I['dog']], z_out[:, I['car']] + self.margin)))
return dl2.And(rules)
def __box_to_constraint(self, box, point):
# x, y = point
box_conditions = []
x_coords = [x for x, y in box]
y_coords = [y for x, y in box]
min_x = min(x_coords)
max_x = max(x_coords)
min_y = min(y_coords)
max_y = max(y_coords)
conditions = dl2.And([
dl2.GEQ(point[:, 0], min_x),
dl2.LEQ(point[:, 0], max_x),
dl2.GEQ(point[:, 1], min_y),
dl2.LEQ(point[:, 1], max_y)
])
return conditions
def train(epoch):
tot_err, tot_dl2_loss = 0, 0
random.shuffle(train_graphs)
for i, g in enumerate(train_graphs):
model.train()
with torch.no_grad():
idx = torch.LongTensor([g.x, g.y])
v = torch.FloatTensor(np.ones(len(g.x)))
adj = torch.sparse.FloatTensor(idx, v,
torch.Size([g.n, g.n])).to_dense()
if args.cuda:
adj = adj.cuda()
optimizer.zero_grad()
out = model.forward(adj)
dist = torch.FloatTensor([g.p[0, i] for i in range(g.n)])
if args.cuda:
dist = dist.cuda()
err = torch.mean((dist - out) * (dist - out))
tot_err += err.detach()
if not args.baseline:
conjunction = []
for a in range(1, g.n):
disjunction = []
for b in range(g.n):
if adj[a, b]:
disjunction.append(dl2.EQ(out[a], out[b] + 1))
conjunction.append(dl2.LEQ(out[a], out[b] + 1))
conjunction.append(dl2.Or(disjunction))
conjunction.append(dl2.EQ(out[0], 0))
for a in range(0, g.n):
conjunction.append(dl2.GEQ(out[0], 0))
constraint = dl2.And(conjunction)
dl2_loss = constraint.loss(args)
dl2_loss.backward()
tot_dl2_loss += dl2_loss.detach()
else:
err.backward()
optimizer.step()
def get_condition(self, z_inp, z_out, x_batches, y_batches):
n_batch = x_batches[0].size()[0]
z_logits = F.log_softmax(z_out[0], dim=1)
d1 = torch.norm(z_inp[0] - x_batches[0], dim=1)
d2 = torch.norm(z_inp[0] - x_batches[1], dim=1)
w1 = d1 / (d1 + d2)
w2 = d2 / (d1 + d2)
pred_logits_1 = z_logits[np.arange(n_batch), y_batches[0]]
pred_logits_2 = z_logits[np.arange(n_batch), y_batches[1]]
pre = dl2.And([
dl2.BoolConst(y_batches[0] != y_batches[1]),
dl2.LEQ(
torch.norm((x_batches[0] - x_batches[1]).view((n_batch, -1)),
dim=1), self.eps)
])
ce = -(w1 * pred_logits_1 + w2 * pred_logits_2)
return dl2.Implication(pre, dl2.LT(ce, self.p_limit))
def train(epoch):
net.train()
train_loss = 0
correct = 0
total = 0
optimizer = optim.Adam(net.parameters(), lr=args.lr)
softmax = torch.nn.Softmax()
print('\n=> Training Epoch #%d, LR=%.4f' %(epoch, args.lr))
if args.skip_labled:
tl = [None] * 200000
else:
tl = trainloader_lab
for batch_idx, (lab, ulab) in enumerate(zip(tl, trainloader_unlab)):
inputs_u, targets_u = ulab
inputs_u, targets_u = Variable(inputs_u), Variable(targets_u)
n_u = inputs_u.size()[0]
if use_cuda:
inputs_u, targets_u = inputs_u.cuda(), targets_u.cuda() # GPU settings
if lab is None:
n = 0
all_outputs = net(inputs_u)
else:
inputs, targets = lab
inputs, targets = Variable(inputs), Variable(targets)
n = inputs.size()[0]
if use_cuda:
inputs, targets = inputs.cuda(), targets.cuda() # GPU settings
all_outputs = net(torch.cat([inputs, inputs_u], dim=0))
optimizer.zero_grad()
outputs_u = all_outputs[n:,]
logits_u = F.log_softmax(outputs_u)
probs_u = softmax(outputs_u)
outputs = all_outputs[:n,]
if args.skip_labled:
ce_loss = 0
else:
outputs = all_outputs[:n,]
ce_loss = criterion(outputs, targets) # Loss
constraint_loss = 0
if args.constraint == 'DL2':
eps = args.c_eps * args.decrease_eps_weight**epoch
dl2_one_group = []
for i in range(20):
gsum = 0
for j in g[i]:
gsum += probs_u[:,j]
dl2_one_group.append(dl2.Or([dl2.EQ(gsum, 1.0), dl2.EQ(gsum, 0.0)]))
dl2_one_group = dl2.And(dl2_one_group)
dl2_loss = dl2_one_group.loss(args).mean()
constraint_loss = dl2_loss
loss = ce_loss + (args.constraint_weight * args.increase_constraint_weight**epoch) * dl2_loss
else:
loss = ce_loss
loss.backward() # Backward Propagation
optimizer.step() # Optimizer update
train_loss += loss.item()
if args.skip_labled:
total = 1
correct = 0
else:
_, predicted = torch.max(outputs.data, 1)
total += targets.size(0)
correct += predicted.eq(targets.data).cpu().sum()
sys.stdout.write('\r')
sys.stdout.write('| Epoch [%3d/%3d] Iter[%3d/%3d]\t\tCE Loss: %.4f, Constraint Loss: %.4f Acc@1: %.3f%%'
%(epoch, num_epochs, batch_idx+1,
(len(train_lab_idx)//batch_size)+1, loss, constraint_loss, 100.*float(correct)/total))
sys.stdout.flush()
return 100.*float(correct)/total
softmax = torch.nn.Softmax()
for batch_idx, (inputs, targets) in enumerate(testloader):
if use_cuda:
inputs, targets = inputs.cuda(), targets.cuda()
inputs, targets = Variable(inputs, volatile=True), Variable(targets)
outputs = net(inputs)
probs = softmax(outputs)
eps = 0.05
dl2_one_group = []
for i in range(20):
gsum = 0
for j in g[i]:
gsum += probs[:, j]
dl2_one_group.append(dl2.Or([dl2.GT(gsum, 1.0 - eps), dl2.LT(gsum, eps)]))
constraint = dl2.And(dl2_one_group)
constraint_correct += constraint.satisfy(args).sum()
_, predicted = torch.max(outputs.data, 1)
total += targets.size(0)
correct += predicted.eq(targets.data).cpu().sum()
conf_mat += confusion_matrix(targets.data.cpu().numpy(), predicted.cpu().numpy(), labels=np.arange(100))
n_batch = predicted.size()[0]
for i in range(n_batch):
if group[predicted.cpu()[i]] == group[targets.cpu().data[i]]:
group_ok += 1
#rint('Confusion matrix:')
#print(conf_mat)