def grad_loc(opt):
loader = DataLoader(SimulatedDataset(opt.test_dir),
batch_size=1,
shuffle=True)
model = Model(nin=True)
model.load_state_dict(torch.load(opt.weights))
loc = GradientLocalizaton(model)
loc.eval()
anchor, same, _ = next(iter(loader))
dist = distance(loc(anchor), loc(same))
print(f"distance: {dist.item()}")
dist.backward()
gradients = loc.gradients
activations = loc.activations(anchor).detach()
superimposed_anchor, anchor = impose(gradients, activations, anchor)
cv2.imwrite("grad_anchor.png", superimposed_anchor)
cv2.imwrite("raw_anchor.png", anchor)
activations = loc.activations(same).detach()
superimposed_same, same = impose(gradients, activations, same)
cv2.imwrite("grad_same.png", superimposed_same)
cv2.imwrite("raw_same.png", same)
def procedure(ticks):
n = 500
b = .000006662
D = 1
alpha = 2
n_types = ticks**D
#print 'Number of types: {}'.format(n_types)
M = np.zeros([ticks**D, ticks**D])
registry = {}
next_id = 0
for index in np.ndindex(tuple([ticks] * D)):
i = index[:D]
registry[i] = next_id
next_id += 1
for index in np.ndindex(tuple([ticks]* D * 2)):
i = index[:D]
j = index[D:]
if i != j:
pos_i = [float(_i) / (ticks - 1) for _i in i]
pos_j = [float(_j) / (ticks - 1) for _j in j]
M[registry[i], registry[j]] = .5 * n**2 / n_types**2 *\
b / (b + model.distance(None, pos_i, pos_j)**alpha)
eigvals = scipy.linalg.eigvals(M)
return max(eigvals)
def procedure(ticks):
n = 500
b = .000006662
D = 1
alpha = 2
n_types = ticks**D
#print 'Number of types: {}'.format(n_types)
M = np.zeros([ticks**D, ticks**D])
registry = {}
next_id = 0
for index in np.ndindex(tuple([ticks] * D)):
i = index[:D]
registry[i] = next_id
next_id += 1
for index in np.ndindex(tuple([ticks] * D * 2)):
i = index[:D]
j = index[D:]
if i != j:
pos_i = [float(_i) / (ticks - 1) for _i in i]
pos_j = [float(_j) / (ticks - 1) for _j in j]
M[registry[i], registry[j]] = .5 * n**2 / n_types**2 *\
b / (b + model.distance(None, pos_i, pos_j)**alpha)
eigvals = scipy.linalg.eigvals(M)
return max(eigvals)
def expected_edge_freq(G):
edge_expected_freq = {}
for u in G._nodes:
for v in G._nodes:
if u < v:
freq = G.c/(model.distance(G, u, v)**2+G.c)
#for when edge_expected_freq[key] since the key can be
#either (u, v) or (v, u)
edge_expected_freq[(u, v)] = freq
edge_expected_freq[(v, u)] = freq
return edge_expected_freq
def expected_edge_freq(G):
edge_expected_freq = {}
for u in G._nodes:
for v in G._nodes:
if u < v:
freq = G.c / (model.distance(G, u, v)**2 + G.c)
#for when edge_expected_freq[key] since the key can be
#either (u, v) or (v, u)
edge_expected_freq[(u, v)] = freq
edge_expected_freq[(v, u)] = freq
return edge_expected_freq
def test(test_loader, model, epoch):
# switch to evaluate mode
model.eval()
labels, distances = [], []
pbar = tqdm(enumerate(test_loader))
for batch_idx, (data_a, data_p, label) in pbar:
current_sample = data_a.size(0)
data_a = data_a.resize_(args.test_input_per_file *current_sample, 1, data_a.size(2), data_a.size(3))
data_p = data_p.resize_(args.test_input_per_file *current_sample, 1, data_a.size(2), data_a.size(3))
if args.cuda:
data_a, data_p = data_a.cuda(), data_p.cuda()
data_a, data_p, label = Variable(data_a, volatile=True), \
Variable(data_p, volatile=True), Variable(label)
# compute output
out_a, out_p = model(data_a), model(data_p)
dists = distance(out_a,out_p, args.distance)
dists = dists.data.cpu().numpy()
dists = dists.reshape(current_sample,args.test_input_per_file).mean(axis=1)
distances.append(dists)
labels.append(label.data.cpu().numpy())
if batch_idx % args.log_interval == 0:
pbar.set_description('Test Epoch: {} [{}/{} ({:.0f}%)]'.format(
# epoch, batch_idx * len(data_a), len(test_loader.dataset),
epoch, batch_idx * len(data_a), len(test_loader) * len(data_a),
100. * batch_idx / len(test_loader)))
labels = np.array([sublabel for label in labels for sublabel in label])
distances = np.array([subdist for dist in distances for subdist in dist])
tpr, fpr, accuracy = evaluate(distances, labels)
print('\33[91mTest set: Accuracy: {:.8f}\n\33[0m'.format(np.mean(accuracy)))
logger.log_value('Test Accuracy', np.mean(accuracy))
def train(train_loader, model, optimizer, epoch):
# switch to train mode
model.train()
labels, distances = [], []
pbar = tqdm(enumerate(train_loader))
for batch_idx, (data_a, data_p, data_n, label_p, label_n) in pbar:
#print("on training{}".format(epoch))
if args.cuda:
data_a, data_p, data_n = data_a.cuda(), data_p.cuda(), data_n.cuda()
# compute output
out_a, out_p, out_n = model(data_a), model(data_p), model(data_n)
if epoch > args.min_softmax_epoch:
triplet_loss = TripletMarginLoss(args.margin).forward(out_a, out_p, out_n)
loss = triplet_loss
# compute gradient and update weights
optimizer.zero_grad()
loss.backward()
optimizer.step()
logger.log_value('selected_triplet_loss', triplet_loss.data.item()).step()
#logger.log_value('selected_cross_entropy_loss', cross_entropy_loss.data.item()).step()
logger.log_value('selected_total_loss', loss.data.item()).step()
if batch_idx % args.log_interval == 0:
pbar.set_description(
'Train Epoch: {:3d} [{:8d}/{:8d} ({:3.0f}%)]\tLoss: {:.6f}'.format(
# epoch, batch_idx * len(data_a), len(train_loader.dataset),
epoch, batch_idx * len(data_a), len(train_loader) * len(data_a),
100. * batch_idx / len(train_loader),
loss.data.item()))
dists = distance(out_a, out_n, args.distance)
distances.append(dists.data.cpu().numpy())
labels.append(np.zeros(dists.size(0)))
dists = distance(out_a, out_p, args.distance)
distances.append(dists.data.cpu().numpy())
labels.append(np.ones(dists.size(0)))
else:
# Choose the hard negatives
d_p = distance(out_a, out_p, args.distance)
d_n = distance(out_a, out_n, args.distance)
all = (d_n - d_p < args.margin).cpu().data.numpy().flatten()
# log loss value for mini batch.
total_coorect = np.where(all == 0)
logger.log_value('Minibatch Train Accuracy', len(total_coorect[0]))
total_dist = (d_n - d_p).cpu().data.numpy().flatten()
logger.log_value('Minibatch Train distance', np.mean(total_dist))
hard_triplets = np.where(all == 1)
if len(hard_triplets[0]) == 0:
continue
if args.cuda:
out_selected_a = Variable(torch.from_numpy(out_a.cpu().data.numpy()[hard_triplets]).cuda())
out_selected_p = Variable(torch.from_numpy(out_p.cpu().data.numpy()[hard_triplets]).cuda())
out_selected_n = Variable(torch.from_numpy(out_n.cpu().data.numpy()[hard_triplets]).cuda())
selected_data_a = Variable(torch.from_numpy(data_a.cpu().data.numpy()[hard_triplets]).cuda())
selected_data_p = Variable(torch.from_numpy(data_p.cpu().data.numpy()[hard_triplets]).cuda())
selected_data_n = Variable(torch.from_numpy(data_n.cpu().data.numpy()[hard_triplets]).cuda())
else:
out_selected_a = Variable(torch.from_numpy(out_a.data.numpy()[hard_triplets]))
out_selected_p = Variable(torch.from_numpy(out_p.data.numpy()[hard_triplets]))
out_selected_n = Variable(torch.from_numpy(out_n.data.numpy()[hard_triplets]))
selected_data_a = Variable(torch.from_numpy(data_a.data.numpy()[hard_triplets]))
selected_data_p = Variable(torch.from_numpy(data_p.data.numpy()[hard_triplets]))
selected_data_n = Variable(torch.from_numpy(data_n.data.numpy()[hard_triplets]))
selected_label_p = torch.from_numpy(label_p.cpu().numpy()[hard_triplets])
selected_label_n= torch.from_numpy(label_n.cpu().numpy()[hard_triplets])
triplet_loss = TripletMarginLoss(args.margin).forward(out_selected_a, out_selected_p, out_selected_n)
cls_a = model.forward_classifier(selected_data_a)
cls_p = model.forward_classifier(selected_data_p)
cls_n = model.forward_classifier(selected_data_n)
criterion = nn.CrossEntropyLoss()
predicted_labels = torch.cat([cls_a,cls_p,cls_n])
if args.cuda:
true_labels = torch.cat([Variable(selected_label_p.cuda()),Variable(selected_label_p.cuda()),Variable(selected_label_n.cuda())])
cross_entropy_loss = criterion(predicted_labels.cuda(),true_labels.cuda())
else:
true_labels = torch.cat([Variable(selected_label_p),Variable(selected_label_p),Variable(selected_label_n)])
cross_entropy_loss = criterion(predicted_labels,true_labels)
loss = cross_entropy_loss + triplet_loss * args.loss_ratio
# compute gradient and update weights
optimizer.zero_grad()
loss.backward()
optimizer.step()
# log loss value for hard selected sample
logger.log_value('selected_triplet_loss', triplet_loss.data).step()
logger.log_value('selected_cross_entropy_loss', cross_entropy_loss.data).step()
logger.log_value('selected_total_loss', loss.data).step()
if batch_idx % args.log_interval == 0:
pbar.set_description(
'Train Epoch: {:3d} [{:8d}/{:8d} ({:3.0f}%)]\tLoss: {:.6f} \t Number of Selected Triplets: {:4d}'.format(
# epoch, batch_idx * len(data_a), len(train_loader.dataset),
epoch, batch_idx * len(data_a), len(train_loader) * len(data_a),
100. * batch_idx / len(train_loader),
loss.data,len(hard_triplets[0])))
dists = distance(out_selected_a, out_selected_n, args.distance)
distances.append(dists.data.cpu().numpy())
labels.append(np.zeros(dists.size(0)))
dists = distance(out_selected_a, out_selected_p, args.distance)
distances.append(dists.data.cpu().numpy())
labels.append(np.ones(dists.size(0)))
#accuracy for hard selected sample, not all sample.
labels = np.array([sublabel for label in labels for sublabel in label])
distances = np.array([subdist for dist in distances for subdist in dist])
tpr, fpr, accuracy = evaluate(distances, labels)
print('\33[91mTrain set: Accuracy: {:.8f}\n\33[0m'.format(np.mean(accuracy)))
logger.log_value('Train Accuracy', np.mean(accuracy))
# do checkpointing
torch.save({'epoch': epoch + 1, 'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict()},
'{}/checkpoint_{}.pth'.format(LOG_DIR, epoch))
# x1=int(input())
# x2=int(input())
# value=add(x1,x2)
# print(value)
#無限參數
# def avg(*ns):
# sum=0
# for n in ns:
# sum=sum+n
# print(sum/(len(ns)))
# avg(3,4)
# avg(3,4,5)
# avg(3,4,5,6)
#模組
# import model
# result=model.distance(1,1,5,5)
# print(result)
# result=model.slope(1,2,5,6)
# print(result)
import sys
sys.path.append("models") #新增路徑
#print(sys.path)
import model
result=model.distance(1,1,5,5)
print(result)
def score():
"""Handle requests for /score via POST"""
# Read strings
s1 = request.form.get("str1")
s2 = request.form.get("str2")
if not s1 or not s2:
abort(400, "missing strings")
# Calculate distance
matrix = distance(s1, s2)
# Extract operations from table
operations = []
i = len(s1)
j = len(s2)
while True:
_, operation = matrix[i][j]
if not operation:
break
if operation == Operation.INSERTED:
j -= 1
elif operation == Operation.DELETED:
i -= 1
else:
i -= 1
j -= 1
operations.append(operation)
operations.reverse()
# Maintain list of intermediate strings, operation and description
transistions = [(s1, None, None)]
i = 0
# Apply each operation
prev = s1
for operation in operations:
# Update sting and description of operation
if operation == Operation.INSERTED:
s = (prev[:i], s2[i], prev[i:])
description = f"inserted '{s2[i]}'"
prev = prev[:i] + s2[i] + prev[i:]
i += 1
elif operation == Operation.DELETED:
s = (prev[:i], prev[i], prev[i + 1:])
description = f"deleted '{prev[i]}'"
prev = prev[:i] + prev[i + 1:]
elif prev[i] != s2[i]:
s = (prev[:i], s2[i], prev[i + 1:])
description = f"substituted '{prev[i]}' with '{s2[i]}'"
prev = prev[:i] + s2[i] + prev[i + 1:]
i += 1
else:
i += 1
continue
transistions.append((s, str(operation), description))
transistions.append((s2, None, None))
# Output comparison
return render_template("score.html",
matrix=matrix,
s1=s1,
s2=s2,
operations=transistions)
