def test_api(self):
paddle.disable_static(self.place)
var_x = paddle.to_tensor(self.input_data)
out = paddle.argsort(var_x, axis=self.axis)
self.assertEqual((out.numpy() == np.array([0, 3, 2, 1])).all(), True)
out = paddle.argsort(var_x, axis=self.axis, descending=True)
self.assertEqual((out.numpy() == np.array([1, 2, 3, 0])).all(), True)
paddle.enable_static()
def reorder_neuron_head(self, model, head_importance, neuron_importance):
# reorder heads and ffn neurons
for layer, current_importance in enumerate(neuron_importance):
# reorder heads
idx = paddle.argsort(head_importance[layer], descending=True)
reorder_head(model.encoder.layers[layer].self_attn, idx)
# reorder neurons
idx = paddle.argsort(paddle.to_tensor(current_importance),
descending=True)
reorder_neuron(model.encoder.layers[layer].linear1, idx, dim=1)
reorder_neuron(model.encoder.layers[layer].linear2, idx, dim=0)
def test_api(self):
paddle.disable_static(self.place)
var_x = paddle.to_tensor(self.input_data)
out = paddle.argsort(var_x, axis=self.axis)
expect = np.argsort(self.input_data, axis=self.axis)
self.assertEqual((expect == out.numpy()).all(), True)
out2 = paddle.argsort(var_x, axis=self.axis, descending=True)
expect2 = np.argsort(-self.input_data, axis=self.axis)
self.assertEqual((expect2 == out2.numpy()).all(), True)
paddle.enable_static()
def test_api_1(self):
paddle.disable_static(self.place)
var_x = paddle.to_variable(self.input_data)
out = paddle.argsort(var_x, axis=-1)
self.assertEqual((np.argsort(self.input_data,
axis=-1) == out.numpy()).all(), True)
paddle.enable_static()
def _masked_language_model(self, sent, word_pieces, mask_id):
tokenized_text = self.tokenizer.tokenize(sent)
tokenized_text = ['[CLS]'] + tokenized_text
tokenized_len = len(tokenized_text)
tokenized_text = word_pieces + ['[SEP]'
] + tokenized_text[1:] + ['[SEP]']
if len(tokenized_text) > 512:
tokenized_text = tokenized_text[:512]
token_ids = self.tokenizer.convert_tokens_to_ids(tokenized_text)
segments_ids = [0] * (tokenized_len + 1) + [1] * (len(tokenized_text) -
tokenized_len - 1)
tokens_tensor = paddle.to_tensor([token_ids])
segments_tensor = paddle.to_tensor([segments_ids])
predictions, _ = self.model(tokens_tensor, segments_tensor)
word_candidates = paddle.argsort(
predictions[0,
mask_id], descending=True)[:self.M].numpy().tolist()
word_candidates = self.tokenizer.convert_ids_to_tokens(word_candidates)
return list(filter(lambda x: x.find("##"), word_candidates))
def _batch_shuffle_ddp(self, x):
"""
Batch shuffle, for making use of BatchNorm.
*** Only support DistributedDataParallel (DDP) model. ***
"""
# gather from all gpus
batch_size_this = x.shape[0]
x_gather = concat_all_gather(x)
batch_size_all = x_gather.shape[0]
num_gpus = batch_size_all // batch_size_this
# random shuffle index
idx_shuffle = paddle.randperm(batch_size_all).cuda()
# broadcast to all gpus
if paddle.distributed.get_world_size() > 1:
paddle.distributed.broadcast(idx_shuffle, src=0)
# index for restoring
idx_unshuffle = paddle.argsort(idx_shuffle)
# shuffled index for this gpu
gpu_idx = paddle.distributed.get_rank()
idx_this = idx_shuffle.reshape([num_gpus, -1])[gpu_idx]
return paddle.index_select(x_gather, idx_this), idx_unshuffle
def forward(self, similarities_matrix, query_img_id, gallery_img_id,
keep_mask):
metric_dict = dict()
#get cmc
choosen_indices = paddle.argsort(similarities_matrix,
axis=1,
descending=True)
gallery_labels_transpose = paddle.transpose(gallery_img_id, [1, 0])
gallery_labels_transpose = paddle.broadcast_to(
gallery_labels_transpose,
shape=[
choosen_indices.shape[0], gallery_labels_transpose.shape[1]
])
choosen_label = paddle.index_sample(gallery_labels_transpose,
choosen_indices)
equal_flag = paddle.equal(choosen_label, query_img_id)
if keep_mask is not None:
keep_mask = paddle.index_sample(keep_mask.astype('float32'),
choosen_indices)
equal_flag = paddle.logical_and(equal_flag,
keep_mask.astype('bool'))
equal_flag = paddle.cast(equal_flag, 'float32')
Ns = paddle.arange(gallery_img_id.shape[0]) + 1
equal_flag_cumsum = paddle.cumsum(equal_flag, axis=1)
Precision_at_k = (paddle.mean(equal_flag_cumsum, axis=0) / Ns).numpy()
for k in self.topk:
metric_dict["precision@{}".format(k)] = Precision_at_k[k - 1]
return metric_dict
def compute(self, pred, label, *args):
"""
Compute the top-k (maxinum value in `topk`) indices.
Args:
pred (Tensor): The predicted value is a Tensor with dtype
float32 or float64. Shape is [batch_size, d0, ..., dN].
label (Tensor): The ground truth value is Tensor with dtype
int64. Shape is [batch_size, d0, ..., 1], or
[batch_size, d0, ..., num_classes] in one hot representation.
Return:
Tensor: Correct mask, a tensor with shape [batch_size, topk].
"""
pred = paddle.argsort(pred, descending=True)
pred = paddle.slice(pred,
axes=[len(pred.shape) - 1],
starts=[0],
ends=[self.maxk])
if (len(label.shape) == 1) or \
(len(label.shape) == 2 and label.shape[-1] == 1):
# In static mode, the real label data shape may be different
# from shape defined by paddle.static.InputSpec in model
# building, reshape to the right shape.
label = paddle.reshape(label, (-1, 1))
elif label.shape[-1] != 1:
# one-hot label
label = paddle.argmax(label, axis=-1, keepdim=True)
correct = pred == label
return paddle.cast(correct, dtype='float32')
def TopPProcess(probs, top_p, min_tokens_to_keep):
sorted_probs = paddle.sort(probs, descending=True)
sorted_indices = paddle.argsort(probs, descending=True)
cumulative_probs = paddle.cumsum(sorted_probs, axis=-1)
# Remove tokens with cumulative probs above the top_p, But keep at
# least min_tokens_to_keep tokens
sorted_indices_to_remove = cumulative_probs > top_p
if min_tokens_to_keep > 1:
# Set 'min_tokens_to_keep - 1' because the first token is kept
sorted_indices_to_remove[:, :min_tokens_to_keep - 1] = 0
# Keep the first token
sorted_indices_to_remove = paddle.cast(sorted_indices_to_remove,
dtype='int64')
sorted_indices_to_remove[:, 1:] = (
sorted_indices_to_remove[:, :-1].clone())
sorted_indices_to_remove[:, 0] = 0
# Scatter sorted tensors to original indexing
sorted_indices = sorted_indices + paddle.arange(
probs.shape[0]).unsqueeze(-1) * probs.shape[-1]
condition = paddle.scatter(sorted_indices_to_remove.flatten(),
sorted_indices.flatten(),
sorted_indices_to_remove.flatten())
condition = paddle.cast(condition, 'bool').reshape(probs.shape)
probs = paddle.where(condition, paddle.full_like(probs, 0.0),
probs)
return probs
def top_k_top_p_filtering(logits, top_k=0, top_p=1.0, filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
Args:
logits: logits distribution shape (vocabulary size)
top_k > 0: keep only top k tokens with highest probability (top-k filtering).
top_p > 0.0: keep the top tokens with cumulative probability >= top_p (nucleus filtering).
Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
"""
top_k = min(top_k, logits.shape[-1]) # Safety check
logits_np = logits.numpy()
if top_k > 0:
# Remove all tokens with a probability less than the last token of the top-k
indices_to_remove = logits_np < np.sort(logits_np)[-top_k]
logits_np[indices_to_remove] = filter_value
if top_p < 1.0:
sorted_logits = paddle.sort(logits, descending=True)
sorted_indices = paddle.argsort(logits, descending=True).numpy()
cumulative_probs = paddle.cumsum(paddle.nn.functional.softmax(sorted_logits, axis=-1), axis=-1).numpy()
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probs > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1]
sorted_indices_to_remove[..., 0] = 0
indices_to_remove = sorted_indices[sorted_indices_to_remove]
logits_np[indices_to_remove] = filter_value
return paddle.to_tensor(logits_np)
def _batch_shuffle_ddp(self, x):
"""
Batch shuffle, for making use of BatchNorm.
"""
# gather from all gpus
batch_size_this = x.shape[0]
x_gather = concat_all_gather(x)
batch_size_all = x_gather.shape[0]
num_gpus = batch_size_all // batch_size_this
idx_shuffle = paddle.randperm(batch_size_all)
if paddle.distributed.get_world_size() > 1:
paddle.distributed.broadcast(idx_shuffle, src=0)
# index for restoring
idx_unshuffle = paddle.argsort(idx_shuffle)
# shuffled index for this gpu
gpu_idx = paddle.distributed.get_rank()
idx_this = idx_shuffle.reshape([num_gpus, -1])[gpu_idx]
x = paddle.gather(x_gather, idx_this, axis=0)
return x, idx_unshuffle
def test_api_1(self):
with fluid.program_guard(fluid.Program()):
input = fluid.data(name="input", shape=[2, 3, 4], dtype="float32")
output = paddle.argsort(x=input, axis=1)
exe = fluid.Executor(self.place)
result, = exe.run(feed={'input': self.data}, fetch_list=[output])
np_result = np.argsort(self.data, axis=1)
self.assertEqual((result == np_result).all(), True)
def forward(self, input):
"""
forward
"""
x = paddle.argsort(input,
axis=self.config['axis'],
descending=self.config['descending'])
return x
def test_api(self):
with fluid.program_guard(fluid.Program()):
input = fluid.data(name="input",
shape=self.input_shape,
dtype="float64")
output = paddle.argsort(input, axis=self.axis)
output2 = paddle.argsort(input, axis=self.axis, descending=True)
exe = fluid.Executor(self.place)
result, result2 = exe.run(feed={'input': self.data},
fetch_list=[output, output2])
np_result = np.argsort(self.data, axis=self.axis)
self.assertEqual((result == np_result).all(), True)
np_result2 = np.argsort(-self.data, axis=self.axis)
self.assertEqual((result2 == np_result2).all(), True)
def reorder_neuron_head(model, head_importance, neuron_importance):
"""
Reorders weights according head importance and neuron importance
"""
from paddleslim.nas.ofa.utils import nlp_utils
# Reorders heads and ffn neurons
for layer, current_importance in enumerate(neuron_importance):
# Reorders heads
idx = paddle.argsort(head_importance[layer], descending=True)
nlp_utils.reorder_head(model.base_model.encoder.layers[layer].self_attn,
idx)
# Reorders neurons
idx = paddle.argsort(
paddle.to_tensor(current_importance), descending=True)
nlp_utils.reorder_neuron(
model.base_model.encoder.layers[layer].linear1.fn, idx, dim=1)
nlp_utils.reorder_neuron(
model.base_model.encoder.layers[layer].linear2.fn, idx, dim=0)
def hard_negative_mining(loss, labels, neg_pos_ratio):
"""
It used to suppress the presence of a large number of negative prediction.
It works on image level not batch level.
For any example/image, it keeps all the positive predictions and
cut the number of negative predictions to make sure the ratio
between the negative examples and positive examples is no more
the given ratio for an image.
Args:
loss (N, num_priors): the loss for each example.
labels (N, num_priors): the labels.
neg_pos_ratio: the ratio between the negative examples and positive examples.
"""
pos_mask = labels > 0
num_pos = pos_mask.cast('int').sum(axis=1, keepdim=True)
num_neg = num_pos * neg_pos_ratio
loss = pos_mask.cast('int') * (-1e8) + loss * (1 - pos_mask.cast('int'))
indexes = paddle.argsort(loss, axis=1, descending=True)
orders = paddle.argsort(indexes, axis=1)
neg_mask = orders < num_neg
return paddle.logical_or(pos_mask, neg_mask)
def compute(self, pred, label, *args):
"""
Compute the top-k (maxinum value in `topk`) indices.
Args:
pred (Tensor): The predicted value is a Tensor wit type
float32 or float64.
label (Tensor): The ground truth value is a 2D Tensor, its
shape is [batch_size, 1] and type is int64.
Return:
Tensor: Correct mask, a tensor with shape [batch_size, topk].
"""
pred = paddle.argsort(pred, descending=True)[:, :self.maxk]
correct = pred == label
return paddle.cast(correct, dtype='float32')
def from_edges(cls, u, v, num_nodes):
self = cls()
self._is_tensor = check_is_tensor(u, v, num_nodes)
if self._is_tensor:
self._degree = paddle.zeros(shape=[num_nodes], dtype="int64")
self._degree = scatter(x=self._degree,
overwrite=False,
index=u,
updates=paddle.ones_like(u, dtype="int64"))
self._sorted_eid = paddle.argsort(u)
self._sorted_u = paddle.gather(u, self._sorted_eid)
self._sorted_v = paddle.gather(v, self._sorted_eid)
self._indptr = op.get_index_from_counts(self._degree)
else:
self._degree, self._sorted_v, self._sorted_u, \
self._sorted_eid, self._indptr = graph_kernel.build_index(u, v, num_nodes)
return self
def compute(self, pred, label, *args):
"""
Processes the pred tensor, and returns the indices of the maximum of each
sample.
Args:
pred (Tensor):
The predicted value is a Tensor with dtype float32 or float64.
Shape is [batch_size, 1].
label (Tensor):
The ground truth value is Tensor with dtype int64, and its
shape is [batch_size, 1].
Returns:
tuple: A tuple of preds and label. Each shape is
[batch_size, 1], with dtype float32 or float64.
"""
preds = paddle.argsort(pred, descending=True)[:, :1]
return (preds, label)
def _weighted_non_max_suppression(self, detections):
"""The alternative NMS method as mentioned in the BlazeFace paper:
The input detections should be a Tensor of shape (count, 17).
Returns a list of Paddle tensors, one for each detected face.
"""
if len(detections) == 0:
return []
output_detections = []
# Sort the detections from highest to lowest score.
remaining = paddle.argsort(detections[:, 16], descending=True).numpy()
detections = detections.numpy()
while len(remaining) > 0:
detection = detections[remaining[0]]
first_box = detection[:4]
other_boxes = detections[remaining, :4]
ious = overlap_similarity(paddle.to_tensor(first_box),
paddle.to_tensor(other_boxes))
mask = ious > self.min_suppression_threshold
mask = mask.numpy()
overlapping = remaining[mask]
remaining = remaining[~mask]
weighted_detection = detection.copy()
if len(overlapping) > 1:
coordinates = detections[overlapping, :16]
scores = detections[overlapping, 16:17]
total_score = scores.sum()
weighted = (coordinates * scores).sum(axis=0) / total_score
weighted_detection[:16] = weighted
weighted_detection[16] = total_score / len(overlapping)
output_detections.append(paddle.to_tensor(weighted_detection))
return output_detections
def forward(self, xyz1, xyz2, points1, points2):
"""
Input:
xyz1: input points position data, [B, C, N]
xyz2: sampled input points position data, [B, C, S]
points1: input points data, [B, D, N]
points2: input points data, [B, D, S]
Return:
new_points: upsampled points data, [B, D', N]
"""
xyz1 = xyz1.transpose([0, 2, 1])
xyz2 = xyz2.transpose([0, 2, 1])
points2 = points2.transpose([0, 2, 1])
B, N, C = xyz1.shape
_, S, _ = xyz2.shape
if S == 1:
interpolated_points = paddle.tile(points2, [1, N, 1])
else:
dists = square_distance(xyz1, xyz2)
dists = paddle.sort(dists, axis=-1)
idx = paddle.argsort(dists, axis=-1)
dists, idx = dists[:, :, :3], idx[:, :, :3] # [B, N, 3]
dist_recip = 1.0 / (dists + 1e-8)
norm = paddle.sum(dist_recip, axis=2, keepdim=True)
weight = dist_recip / norm
interpolated_points = paddle.sum(index_points(points2, idx) * weight.reshape([B, N, 3, 1]), axis=2)
if points1 is not None:
points1 = points1.transpose([0, 2, 1])
new_points = paddle.concat([points1, interpolated_points], axis=-1)
else:
new_points = interpolated_points
new_points = new_points.transpose([0, 2, 1])
for i, conv in enumerate(self.mlp_convs):
bn = self.mlp_bns[i]
new_points = F.relu(bn(conv(new_points)))
return new_points
def forward(self, similarities_matrix, query_img_id, gallery_img_id,
keep_mask):
metric_dict = dict()
choosen_indices = paddle.argsort(similarities_matrix,
axis=1,
descending=True)
gallery_labels_transpose = paddle.transpose(gallery_img_id, [1, 0])
gallery_labels_transpose = paddle.broadcast_to(
gallery_labels_transpose,
shape=[
choosen_indices.shape[0], gallery_labels_transpose.shape[1]
])
choosen_label = paddle.index_sample(gallery_labels_transpose,
choosen_indices)
equal_flag = paddle.equal(choosen_label, query_img_id)
if keep_mask is not None:
keep_mask = paddle.index_sample(keep_mask.astype('float32'),
choosen_indices)
equal_flag = paddle.logical_and(equal_flag,
keep_mask.astype('bool'))
equal_flag = paddle.cast(equal_flag, 'float32')
num_rel = paddle.sum(equal_flag, axis=1)
num_rel = paddle.greater_than(num_rel, paddle.to_tensor(0.))
num_rel_index = paddle.nonzero(num_rel.astype("int"))
num_rel_index = paddle.reshape(num_rel_index, [num_rel_index.shape[0]])
equal_flag = paddle.index_select(equal_flag, num_rel_index, axis=0)
acc_sum = paddle.cumsum(equal_flag, axis=1)
div = paddle.arange(acc_sum.shape[1]).astype("float32") + 1
precision = paddle.divide(acc_sum, div)
#calc map
precision_mask = paddle.multiply(equal_flag, precision)
ap = paddle.sum(precision_mask, axis=1) / paddle.sum(equal_flag,
axis=1)
metric_dict["mAP"] = paddle.mean(ap).numpy()[0]
return metric_dict
def forward(self, similarities_matrix, query_img_id, gallery_img_id,
keep_mask):
metric_dict = dict()
choosen_indices = paddle.argsort(similarities_matrix,
axis=1,
descending=True)
gallery_labels_transpose = paddle.transpose(gallery_img_id, [1, 0])
gallery_labels_transpose = paddle.broadcast_to(
gallery_labels_transpose,
shape=[
choosen_indices.shape[0], gallery_labels_transpose.shape[1]
])
choosen_label = paddle.index_sample(gallery_labels_transpose,
choosen_indices)
equal_flag = paddle.equal(choosen_label, query_img_id)
if keep_mask is not None:
keep_mask = paddle.index_sample(keep_mask.astype('float32'),
choosen_indices)
equal_flag = paddle.logical_and(equal_flag,
keep_mask.astype('bool'))
equal_flag = paddle.cast(equal_flag, 'float32')
num_rel = paddle.sum(equal_flag, axis=1)
num_rel = paddle.greater_than(num_rel, paddle.to_tensor(0.))
num_rel_index = paddle.nonzero(num_rel.astype("int"))
num_rel_index = paddle.reshape(num_rel_index, [num_rel_index.shape[0]])
equal_flag = paddle.index_select(equal_flag, num_rel_index, axis=0)
#do accumulative sum
div = paddle.arange(equal_flag.shape[1]).astype("float32") + 2
minus = paddle.divide(equal_flag, div)
auxilary = paddle.subtract(equal_flag, minus)
hard_index = paddle.argmax(auxilary, axis=1).astype("float32")
all_INP = paddle.divide(paddle.sum(equal_flag, axis=1), hard_index)
mINP = paddle.mean(all_INP)
metric_dict["mINP"] = mINP.numpy()[0]
return metric_dict
def forward(self, similarities_matrix, query_img_id, gallery_img_id,
keep_mask):
metric_dict = dict()
#get cmc
choosen_indices = paddle.argsort(similarities_matrix,
axis=1,
descending=True)
gallery_labels_transpose = paddle.transpose(gallery_img_id, [1, 0])
gallery_labels_transpose = paddle.broadcast_to(
gallery_labels_transpose,
shape=[
choosen_indices.shape[0], gallery_labels_transpose.shape[1]
])
choosen_label = paddle.index_sample(gallery_labels_transpose,
choosen_indices)
equal_flag = paddle.equal(choosen_label, query_img_id)
if keep_mask is not None:
keep_mask = paddle.index_sample(keep_mask.astype('float32'),
choosen_indices)
equal_flag = paddle.logical_and(equal_flag,
keep_mask.astype('bool'))
equal_flag = paddle.cast(equal_flag, 'float32')
real_query_num = paddle.sum(equal_flag, axis=1)
real_query_num = paddle.sum(
paddle.greater_than(real_query_num,
paddle.to_tensor(0.)).astype("float32"))
acc_sum = paddle.cumsum(equal_flag, axis=1)
mask = paddle.greater_than(acc_sum,
paddle.to_tensor(0.)).astype("float32")
all_cmc = (paddle.sum(mask, axis=0) / real_query_num).numpy()
for k in self.topk:
metric_dict["recall{}".format(k)] = all_cmc[k - 1]
return metric_dict
def _sort_score(self, scores, top_num):
if paddle.shape(scores)[0] > top_num:
return paddle.topk(scores, top_num)[1]
else:
return paddle.argsort(scores, descending=True)
def forward(self, inputs):
return paddle.argsort(inputs, axis=-1, descending=True)
def decode(self, x_tree_vecs, prob_decode):
"""
Decode tree structre from tree latent space.
Args:
x_tree_mess(tensor): tree latent represenation.
prob_decode(bool): using bernoulli distribution in tree decode if prob_decode=true.
Returns:
root node and all nodes.
"""
assert x_tree_vecs.shape[0] == 1
stack = []
init_hiddens = paddle.zeros([1, self.hidden_size])
zero_pad = paddle.zeros([1, 1, self.hidden_size])
contexts = paddle.zeros([1]).astype('int64')
root_score = self.aggregate(init_hiddens, contexts, x_tree_vecs, 'word')
root_wid = paddle.argmax(root_score, axis=1)
root_wid = int(root_wid.numpy())
root = MolTreeNode(self.vocab.get_smiles(root_wid))
root.wid = root_wid
root.idx = 0
stack.append((root, self.vocab.get_slots(root.wid)))
all_nodes = [root]
h = {}
for step in range(MAX_DECODE_LEN):
node_x, fa_slot = stack[-1]
cur_h_nei = [h[(node_y.idx, node_x.idx)] for node_y in node_x.neighbors]
if len(cur_h_nei) > 0:
cur_h_nei = paddle.reshape(paddle.stack(cur_h_nei, axis=0), shape=[1, -1, self.hidden_size])
else:
cur_h_nei = zero_pad
cur_x = paddle.to_tensor([node_x.wid])
cur_x = self.embedding(cur_x)
cur_h = paddle.sum(cur_h_nei, axis=1)
stop_hiddens = paddle.concat([cur_x, cur_h], axis=1)
stop_hiddens = F.relu(self.U_i(stop_hiddens))
stop_score = self.aggregate(stop_hiddens, contexts, x_tree_vecs, 'stop')
if prob_decode:
backtrack = (paddle.bernoulli(F.sigmoid(stop_score)).item() == 0)
else:
backtrack = (float(stop_score.numpy()) < 0)
if not backtrack:
new_h = GRU(cur_x, cur_h_nei, self.W_z, self.W_r, self.U_r, self.W_h)
pred_score = self.aggregate(new_h, contexts, x_tree_vecs, 'word')
if prob_decode:
sort_wid = paddle.multinomial(F.softmax(pred_score, axis=1).squeeze(), 5)
else:
sort_wid = paddle.argsort(
pred_score, axis=1, descending=True)
sort_wid = sort_wid.squeeze()
next_wid = None
for wid in sort_wid[:5]:
slots = self.vocab.get_slots(wid)
node_y = MolTreeNode(self.vocab.get_smiles(wid))
if have_slots(fa_slot, slots) and can_assemble(node_x, node_y):
next_wid = wid
next_slots = slots
break
if next_wid is None:
backtrack = True
else:
node_y = MolTreeNode(self.vocab.get_smiles(next_wid))
node_y.wid = int(next_wid.numpy())
node_y.idx = len(all_nodes)
node_y.neighbors.append(node_x)
h[(node_x.idx, node_y.idx)] = new_h[0]
stack.append((node_y, next_slots))
all_nodes.append(node_y)
if backtrack:
if len(stack) == 1:
break
node_fa, _ = stack[-2]
cur_h_nei = [h[(node_y.idx, node_x.idx)] for node_y in node_x.neighbors if node_y.idx != node_fa.idx]
if len(cur_h_nei) > 0:
cur_h_nei = paddle.reshape(paddle.stack(cur_h_nei, axis=0), shape=[1, -1, self.hidden_size])
else:
cur_h_nei = zero_pad
new_h = GRU(cur_x, cur_h_nei, self.W_z, self.W_r, self.U_r, self.W_h)
h[(node_x.idx, node_fa.idx)] = new_h[0]
node_fa.neighbors.append(node_x)
stack.pop()
return root, all_nodes
loss.backward()
opt.step()
opt.clear_grad()
model = MyNet()
train(model)
near_neighbours_per_example = 10
x_test_t = paddle.to_tensor(x_test)
test_images_embeddings = model(x_test_t)
similarities_matrix = paddle.matmul(test_images_embeddings,
test_images_embeddings,
transpose_y=True)
indicies = paddle.argsort(similarities_matrix, descending=True)
indicies = indicies.numpy()
examples = np.empty(
(
num_classes,
near_neighbours_per_example + 1,
3,
height_width,
height_width,
),
dtype=np.float32,
)
for row_idx in range(num_classes):
examples_for_class = class_idx_to_test_idxs[row_idx]
anchor_idx = random.choice(examples_for_class)
def dfs_assemble(self, y_tree_mess, x_mol_vecs, all_nodes, cur_mol, global_amap, fa_amap, cur_node, fa_node,
prob_decode, check_aroma):
"""DFS in subgraph assembly"""
fa_nid = fa_node.nid if fa_node is not None else -1
prev_nodes = [fa_node] if fa_node is not None else []
children = [nei for nei in cur_node.neighbors if nei.nid != fa_nid]
neighbors = [nei for nei in children if nei.mol.GetNumAtoms() > 1]
neighbors = sorted(neighbors, key=lambda x: x.mol.GetNumAtoms(), reverse=True)
singletons = [nei for nei in children if nei.mol.GetNumAtoms() == 1]
neighbors = singletons + neighbors
cur_amap = [(fa_nid, a2, a1) for nid, a1, a2 in fa_amap if nid == cur_node.nid]
cands, aroma_score = enum_assemble(cur_node, neighbors, prev_nodes, cur_amap)
if len(cands) == 0 or (sum(aroma_score) < 0 and check_aroma):
return None, cur_mol
cand_smiles, cand_amap = zip(*cands)
aroma_score = paddle.to_tensor(aroma_score)
cands = [(smiles, all_nodes, cur_node) for smiles in cand_smiles]
if len(cands) > 1:
jtmpn_holder = JTMPN.tensorize(cands, y_tree_mess[1])
fatoms = jtmpn_holder['fatoms']
fbonds = jtmpn_holder['fbonds']
agraph = jtmpn_holder['agraph']
bgraph = jtmpn_holder['bgraph']
scope = jtmpn_holder['scope']
cand_vecs = self.jtmpn(fatoms, fbonds, agraph, bgraph, scope, y_tree_mess[0])
scores = paddle.mv(cand_vecs, x_mol_vecs) + aroma_score
else:
scores = paddle.to_tensor([1.0])
if prob_decode:
probs = paddle.squeeze(F.softmax(paddle.reshape(scores, shape=[1, -1]), axis=1)) + 1e-7
cand_idx = paddle.multinomial(probs, probs.numel())
else:
cand_idx = paddle.argsort(scores, descending=True)
backup_mol = Chem.RWMol(cur_mol)
pre_mol = cur_mol
for i in range(cand_idx.numel()):
cur_mol = Chem.RWMol(backup_mol)
pred_amap = cand_amap[int(cand_idx[i].numpy())]
new_global_amap = copy.deepcopy(global_amap)
for nei_id, ctr_atom, nei_atom in pred_amap:
if nei_id == fa_nid:
continue
new_global_amap[nei_id][nei_atom] = new_global_amap[cur_node.nid][ctr_atom]
cur_mol = attach_mols(cur_mol, children, [], new_global_amap)
new_mol = cur_mol.GetMol()
new_mol = Chem.MolFromSmiles(Chem.MolToSmiles(new_mol))
if new_mol is None:
continue
has_error = False
for nei_node in children:
if nei_node.is_leaf:
continue
tmp_mol, tmp_mol2 = self.dfs_assemble(y_tree_mess, x_mol_vecs, all_nodes, cur_mol, new_global_amap,
pred_amap, nei_node, cur_node, prob_decode, check_aroma)
if tmp_mol is None:
has_error = True
if i == 0: pre_mol = tmp_mol2
break
cur_mol = tmp_mol
if not has_error: return cur_mol, cur_mol
return None, pre_mol
def test_paddle_var_type():
with fluid.program_guard(fluid.Program()):
x = [1]
output = paddle.argsort(input=x)
self.assertRaises(TypeError, test_paddle_var_type)
