def L2_penalty(model):
loss = 0
for parameter in model.parameters():
if parameter.dim() == 1:
continue
loss += torch.sum(torch.addcmul(float, parameter, parameter))
return loss
def backward(self, grad_output):
input_img, output = self.saved_tensors
grad_input = None
positive_mask_1 = (input_img > 0).type_as(grad_output)
positive_mask_2 = (grad_output > 0).type_as(grad_output)
grad_input = torch.addcmul(
torch.zeros(input_img.size()).type_as(input_img),
torch.addcmul(
torch.zeros(input_img.size()).type_as(input_img),
grad_output,
positive_mask_1,
),
positive_mask_2,
)
return grad_input
def train(model, criterion, epoch, optimizer, training_data_loader, Loss):
lr = adjust_learning_rate(epoch - 1)
for param_group in optimizer.param_groups:
param_group["lr"] = lr
print("Epoch = {}, lr = {}".format(epoch, optimizer.param_groups[0]["lr"]))
epoch_loss = 0
for iteration, batch in enumerate(training_data_loader, 1):
input, target = Variable(batch[0]), Variable(batch[1],
requires_grad=False)
if opt.cuda:
input = input.cuda()
target = target.cuda()
optimizer.zero_grad() #清空所有被优化过的Variable的梯度.
model_out = model(input)
#prediction = torch.zeros(target.shape[0], target.shape[2], target.shape[3]).cuda()
prediction = torch.addcmul(model_out[:, 1, :, :], 1,
model_out[:, 0, :, :], input[:, 1, :, :])
loss = criterion(prediction, target[:, 0, :, :])
epoch_loss += loss.item()
loss.backward()
#nn.utils.clip_grad_norm_(model.parameters(), opt.clip/lr)
optimizer.step() #进行单次优化参数更新
print("===> Epoch[{}]({}/{}): Loss: {:.4f}".format(
epoch, iteration, len(training_data_loader), loss.item()))
Loss.append(epoch_loss / len(training_data_loader))
print("===> Epoch {} Complete: Avg. Loss: {:.4f}".format(
epoch, epoch_loss / len(training_data_loader)))
def forward(self, invec):
x, sumgrad = invec[0], invec[1]
residualx = x
out = self.bn1(x)
out = self.relu(out)
out = self.conv1(out)
out = self.bn2(out)
out = self.relu(out)
out = self.conv2(out)
out = self.bn3(out)
out = self.relu(out)
out = self.conv3(out)
if self.downsample is not None:
residualx = self.downsample(x)
if self.downsamplegrad is not None:
sumgrad = self.downsamplegrad(torch.rsqrt(sumgrad))
sumgrad = sumgrad * sumgrad
sumgrad = torch.addcmul(sumgrad, value=1.0, tensor1=out, tensor2=out)
out = out * torch.rsqrt(sumgrad + 1e-8)
out = out + residualx
return [out, sumgrad]
def forward(self, input):
positive_mask = (input > 0).type_as(input)
output = torch.addcmul(
torch.zeros(input.size()).type_as(input), input, positive_mask)
self.save_for_backward(input, output)
return output
def update_usages(self, prev_write_distribution, prev_read_distributions, free_gates):
# Read distributions shape: [batch, n_heads, cell count]
# Free gates shape: [batch, n_heads]
self._init_consts(prev_read_distributions.device)
phi = torch.addcmul(self.one, -1, free_gates.unsqueeze(-1), prev_read_distributions).prod(-2)
# Phi is the free tensor, sized [batch, cell count]
# If memory usage counter if doesn't exists
if self.usages is None:
self._init_sequence(prev_read_distributions)
# in first timestep nothing is written or read yet, so we don't need any further processing
else:
self.usages = torch.addcmul(self.usages, 1, prev_write_distribution.detach(), (1 - self.usages)) * phi
return phi
def forward(self, pred, true):
t1 = torch.exp(torch.mul(pred, 2-self.rho, out=None), out=None)
t = torch.mul(t1, 1/(2-self.rho), out=None)
t2 = torch.exp(torch.mul(pred, 1-self.rho, out=None), out=None)
loss = torch.mean(torch.addcmul(t, -1/(1 -self.rho), true, t2, out=None))
return loss
def forward(self, x):
residual = x
out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)
out = self.conv2(out)
out = self.bn2(out)
out = self.relu(out)
out = self.conv3(out)
out = self.bn3(out)
if self.downsample is not None:
residual = self.downsample(x)
if self.squeeze is None:
out += residual
else:
if self.fused_se:
out = torch.addcmul(residual, out, self.squeeze(out), value=1)
else:
out = residual + out * self.squeeze(out)
out = self.relu(out)
return out
def logm(self, x, y):
"""Logarithmic map on the Lorenz Manifold"""
xy = th.clamp(self.ldot(x, y).unsqueeze(-1), max=-1)
v = acosh(-xy, self.eps).div_(
th.clamp(th.sqrt(xy * xy - 1), min=self._eps)) * th.addcmul(
y, xy, x)
return self.normalize_tan(x, v)
def learn(self):
if len(self.replay_buffer) > self.batch_size:
states, actions, rewards, new_states, dones = self.replay_buffer.sample(
self.batch_size)
with torch.no_grad():
target_actions = self.target_actor.forward(new_states)
critic_value_ = self.target_critic.forward(
torch.concat((new_states, target_actions), dim=-1))
critic_value = self.critic.forward(
torch.concat((states, actions), dim=-1))
target = torch.addcmul(rewards, self.gamma, 1 - dones,
critic_value_.squeeze()).view(
self.batch_size, 1)
self.critic.optimizer.zero_grad()
critic_loss = torch.nn.functional.mse_loss(target, critic_value)
critic_loss.backward()
self.critic.optimizer.step()
self.actor.optimizer.zero_grad()
actions = self.actor.forward(states)
actor_loss = -self.critic.forward(
torch.concat((states, actions), dim=-1))
actor_loss = torch.mean(actor_loss)
actor_loss.backward()
self.actor.optimizer.step()
self.target_critic.converge_to(self.critic, tau=self.tau)
self.target_actor.converge_to(self.actor, tau=self.tau)
def style_mod(x, style):
style = style.view(style.shape[0], 2, x.shape[1], 1,
1) # [n,1024] -> [n,2,512,1,1]
return torch.addcmul(style[:, 1],
value=1.0,
tensor1=x,
tensor2=style[:, 0] + 1) # style1 + x*style2
def forward(ctx, input, gamma, beta, eps=1e-5):
"""
Compute the batch normalization
Args:
ctx: context object handling storing and retrival of tensors and constants and specifying
whether tensors need gradients in backward pass
input: input tensor of shape (B, n_neurons)
gamma: variance scaling tensor, applied per neuron, shape (n_neurons)
beta: mean bias tensor, applied per neuron, shape (n_neurons)
eps: small float added to the variance for stability
Returns:
out: batch-x_hat tensor
"""
########################
# PUT YOUR CODE HERE #
#######################
requires_grad = False
mean = input.mean(dim=0)
var = input.var(dim=0, unbiased=False)
denom = (var + eps).sqrt()
x_hat = (input - mean) / denom
out = torch.addcmul(beta, gamma, x_hat)
ctx.save_for_backward(gamma, denom, x_hat)
########################
# END OF YOUR CODE #
#######################
return out
def test_remote_tensor_tertiary_methods(self):
hook = TorchHook(verbose=False)
local = hook.local_worker
remote = VirtualWorker(hook, 1)
local.add_worker(remote)
x = torch.FloatTensor([1, 2, 3]).send(remote)
y = torch.FloatTensor([1, 2, 3]).send(remote)
z = torch.FloatTensor([1, 2, 3]).send(remote)
assert (torch.equal(
torch.addcmul(z, 2, x, y).get(), torch.FloatTensor([3., 10.,
21.])))
x = torch.FloatTensor([1, 2, 3]).send(remote)
y = torch.FloatTensor([1, 2, 3]).send(remote)
z = torch.FloatTensor([1, 2, 3]).send(remote)
z.addcmul_(2, x, y)
assert (torch.equal(z.get(), torch.FloatTensor([3., 10., 21.])))
x = torch.FloatTensor([[1, 2]]).send(remote)
y = torch.FloatTensor([[1, 2, 3], [4, 5, 6]]).send(remote)
z = torch.FloatTensor([1, 2, 3]).send(remote)
assert (torch.equal(
torch.addmm(z, x, y).get(), torch.FloatTensor([[10., 14., 18.]])))
def forward(self, input):
"""
Compute the batch normalization
Args:
input: input tensor of shape (B, n_neurons)
Returns:
out: batch-x_hat tensor
"""
########################
# PUT YOUR CODE HERE #
#######################
(_n_batch, n_neurons) = input.shape
assert n_neurons == self.n_neurons
mean = input.mean(dim=0)
var = input.var(dim=0, unbiased=False)
x_hat = (input - mean) / (var + self.eps).sqrt()
p = self.params
out = torch.addcmul(p['beta'], p['gamma'], x_hat)
########################
# END OF YOUR CODE #
#######################
return out
def RecToPolar_3(RectData):
'''
Implement cartesian coordinate to polar coordinate
imput:
the array of cartesian coordinate
output:
the polar coodinate
'''
# RectData=yy
# print(RectData.size())
SizeOfData = RectData.size()
if (SizeOfData[2] == 3):
# print(RectData[0:3,:])
ListSmall = 1e-16 #use a small num for illegal divition
R = torch.norm(RectData, p=2, dim=2) + ListSmall
# print(R)
Phi_Value = torch.addcdiv(torch.zeros_like(R), 1, RectData[:, :, 2], R)
Phi = torch.acos(Phi_Value) #利用反余弦函数求出俯仰角
r = torch.addcmul(torch.zeros_like(R), 1, R,
torch.sin(Phi)) + ListSmall
Theta_Value = torch.addcdiv(torch.zeros_like(r), 1, RectData[:, :, 0],
r)
SignalOfNum = torch.lt(RectData[:, :, 1],
torch.zeros_like(Theta_Value)).double()
Flag_Signal_Coe = (-2 * SignalOfNum + 1)
Flag_Fixed_Tail = np.pi * 2 * SignalOfNum
Theta = torch.acos(
Theta_Value).double() * Flag_Signal_Coe + Flag_Fixed_Tail
result = torch.cat(
(torch.unsqueeze(R.double(), 2), torch.unsqueeze(
Theta.double(), 2), torch.unsqueeze(Phi.double(), 2)),
dim=2)
return (result)
def validate(model, criterion, validating_data_loader, PSNR, RMSE):
avg_psnr = 0
avg_rmse = 0
for batch in validating_data_loader:
input, target = Variable(batch[0]), Variable(batch[1])
if opt.cuda:
input = input.cuda()
target = target.cuda()
model_out = model(input)
#prediction = torch.zeros(target.shape[0], target.shape[2], target.shape[3]).cuda()
prediction = torch.addcmul(model_out[:, 1, :, :], 1,
model_out[:, 0, :, :], input[:, 1, :, :])
mse = criterion(prediction * 255.0, target[:, 0, :, :] * 255.0)
rmse = sqrt(mse.item())
psnr = 10 * log10(255.0**2 / mse.item())
avg_rmse += rmse
avg_psnr += psnr
PSNR.append(avg_psnr / len(validating_data_loader))
RMSE.append(avg_rmse / len(validating_data_loader))
print("===> Avg. PSNR: {:.4f} dB".format(avg_psnr /
len(validating_data_loader)))
print("===> Avg. RMSE: {:.4f}".format(avg_rmse /
len(validating_data_loader)))
def point_map_to_seg(pt_map, seg):
# pt_map: h x w x 2
# seg: 2 x 2 => list, tuple, ...
h, w, _ = pt_map.size()
p1_map = torch.Tensor(seg[0]).expand(h, w, -1)
p2_map = torch.Tensor(seg[1]).expand(h, w, -1)
sub_p1_map = pt_map.sub(p1_map)
# cross: (p-p1).dot(p2-p1)
cross = sub_p1_map[:, :, 0].mul(seg[1][0] - seg[0][0]).add(
sub_p1_map[:, :, 1].mul(seg[1][1] - seg[0][1]))
mask_1 = cross.le(0).float() # p1 side
dist_map = mask_1.mul(sub_p1_map.pow(2).sum(2))
# seg_d2: ||p2-p1||^2
seg_d2 = (seg[1][0] - seg[0][0])**2 + (seg[1][1] - seg[0][1])**2
mask_2 = cross.ge(seg_d2).float() # p2 side
dist_map.add_(mask_2.mul(pt_map.sub(p2_map).pow_(2).sum(2)))
# between p1 and p2
mask_3 = mask_1.max(mask_2).eq(0).float()
seg_d2 = max(seg_d2, 1e-6)
cross.div_(seg_d2)
q_map = torch.addcmul(p1_map,
cross.view(h, w, 1).expand(h, w, 2),
p2_map.sub(p1_map))
dist_map.add_(mask_3.mul(pt_map.sub(q_map).pow_(2).sum(2)))
return dist_map
def forward(self, input_tensor):
positive_mask = (input_tensor > 0).type_as(input_tensor)
output = torch.addcmul(
torch.zeros(input_tensor.size()).type_as(input_tensor),
input_tensor, positive_mask)
self.save_for_backward(input_tensor, output)
return output
def apply_mean_var(x, mean, var, eps):
inv_stdev = torch.rsqrt(torch.max(var, eps))
return torch.addcmul((-mean * inv_stdev).to(x.dtype),
inv_stdev.to(x.dtype),
x,
value=1.0)
def forward(self, input):
shape = input.size()
# In order to force the cudnn path, everything needs to be
# contiguous. Hence the check here and reallocation below.
if not input.is_contiguous():
input = input.contiguous()
input = input.view(1, -1, shape[-1])
# Expand w and b buffers if necessary.
n = input.size(1)
cur = self.dummy.numel() if self.dummy is not None else 0
if cur == 0:
self.dummy = input.data.new(n)
self.w = input.data.new(n).fill_(1)
self.b = input.data.new(n).zero_()
elif n > cur:
self.dummy.resize_(n)
self.w.resize_(n)
self.w[cur:n].fill_(1)
self.b.resize_(n)
self.b[cur:n].zero_()
dummy = self.dummy[:n]
w = self.w[:n]
b = self.b[:n]
output = F.batch_norm(input, dummy, dummy, w, b, True, 0., self.eps)
return torch.addcmul(self.bias, 1, output.view(*shape), self.gain)
def forward(self, feat, label, easy_margin=False):
eps = 1e-4
batch_size = feat.shape[0]
norms = torch.norm(feat, p=2, dim=-1, keepdim=True)
feat_l2norm = torch.div(feat, norms)
feat_l2norm = feat_l2norm.clamp(min=-1 + eps,
max=1 - eps) # for numerical stability
feat_l2norm = feat_l2norm * self.s
norms_w = torch.norm(self.weights, p=2, dim=-1, keepdim=True)
weights_l2norm = torch.div(self.weights, norms_w)
weights_l2norm = weights_l2norm.clamp(min=-1 + eps, max=1 -
eps) # for numerical stability
fc7 = torch.matmul(feat_l2norm, torch.transpose(weights_l2norm, 0, 1))
# zy = mx.sym.pick(fc7, gt_label, axis=1)
label = label.cpu()
fc7 = fc7.cpu()
target_one_hot = torch.zeros(len(label), NUM_OF_CLASSES).scatter_(
1, label.unsqueeze(1), 1.)
zy = torch.addcmul(torch.zeros(fc7.size()), 1., fc7, target_one_hot)
zy = zy.sum(-1)
cos_t = zy / self.s
cos_t = cos_t.clamp(min=-1 + eps,
max=1 - eps) # for numerical stability
t = torch.acos(cos_t)
t = t + self.m
body = torch.cos(t)
new_zy = body * self.s
diff = new_zy - zy
# diff = mx.sym.expand_dims(diff, 1)
diff = diff.unsqueeze(1)
# gt_one_hot = mx.sym.one_hot(gt_label, depth = args.num_classes, on_value = 1.0, off_value = 0.0)
# body = mx.sym.broadcast_mul(gt_one_hot, diff)
body = torch.addcmul(torch.zeros(diff.size()), 1., diff,
target_one_hot)
output = fc7 + body
return output.to(self.device)
def _jit_linear_cg_updates(result, alpha, residual_inner_prod, eps, beta,
residual, precond_residual, mul_storage,
curr_conjugate_vec):
# # Update result
# # result_{k} = result_{k-1} + alpha_{k} p_vec_{k-1}
torch.addcmul(result, alpha, curr_conjugate_vec, out=result)
# beta_{k} = (precon_residual{k}^T r_vec_{k}) / (precon_residual{k-1}^T r_vec_{k-1})
residual_inner_prod.add_(eps)
torch.reciprocal(residual_inner_prod, out=beta)
torch.mul(residual, precond_residual, out=mul_storage)
torch.sum(mul_storage, -2, keepdim=True, out=residual_inner_prod)
beta.mul_(residual_inner_prod)
# Update curr_conjugate_vec
# curr_conjugate_vec_{k} = precon_residual{k} + beta_{k} curr_conjugate_vec_{k-1}
curr_conjugate_vec.mul_(beta).add_(precond_residual)
def _jit_linear_cg_updates_no_precond(
mvms,
result,
has_converged,
alpha,
residual_inner_prod,
eps,
beta,
residual,
precond_residual,
mul_storage,
is_zero,
curr_conjugate_vec,
):
torch.mul(curr_conjugate_vec, mvms, out=mul_storage)
torch.sum(mul_storage, dim=-2, keepdim=True, out=alpha)
# Do a safe division here
torch.lt(alpha, eps, out=is_zero)
alpha.masked_fill_(is_zero, 1)
torch.div(residual_inner_prod, alpha, out=alpha)
alpha.masked_fill_(is_zero, 0)
# We'll cancel out any updates by setting alpha=0 for any vector that has already converged
alpha.masked_fill_(has_converged, 0)
# Update residual
# residual_{k} = residual_{k-1} - alpha_{k} mat p_vec_{k-1}
torch.addcmul(residual, -alpha, mvms, out=residual)
# Update precond_residual
# precon_residual{k} = M^-1 residual_{k}
precond_residual = residual.clone()
_jit_linear_cg_updates(
result,
alpha,
residual_inner_prod,
eps,
beta,
residual,
precond_residual,
mul_storage,
is_zero,
curr_conjugate_vec,
)
def backward(self, y):
grad = None
x, output = self.saved_tensors
grad = torch.addcmul(torch.zeros(y.size()), y, (y > 0).type_as(y))
grad[x <= 0] = 0
return grad
def forward(self, x, s1, s2, noise):
if self.has_first_conv:
if not self.fused_scale:
x = upscale2d(x)
x = self.conv_1(x)
x = self.blur(x)
if noise:
if noise == 'batch_constant':
x = torch.addcmul(x, value=1.0, tensor1=self.noise_weight_1,
tensor2=torch.randn([1, 1, x.shape[2], x.shape[3]]))
else:
x = torch.addcmul(x, value=1.0, tensor1=self.noise_weight_1,
tensor2=torch.randn([x.shape[0], 1, x.shape[2], x.shape[3]]))
else:
s = math.pow(self.layer + 1, 0.5)
x = x + s * torch.exp(-x * x / (2.0 * s * s)) / math.sqrt(2 * math.pi) * 0.8
x = x + self.bias_1
x = F.leaky_relu(x, 0.2)
x = self.instance_norm_1(x)
x = style_mod(x, self.style_1(s1))
x = self.conv_2(x)
if noise:
if noise == 'batch_constant':
x = torch.addcmul(x, value=1.0, tensor1=self.noise_weight_2,
tensor2=torch.randn([1, 1, x.shape[2], x.shape[3]]))
else:
x = torch.addcmul(x, value=1.0, tensor1=self.noise_weight_2,
tensor2=torch.randn([x.shape[0], 1, x.shape[2], x.shape[3]]))
else:
s = math.pow(self.layer + 1, 0.5)
x = x + s * torch.exp(-x * x / (2.0 * s * s)) / math.sqrt(2 * math.pi) * 0.8
x = x + self.bias_2
x = F.leaky_relu(x, 0.2)
x = self.instance_norm_2(x)
x = style_mod(x, self.style_2(s2))
return x
def forward(self, input):
self._check_input_dim(input)
if self.momentum is None:
exponential_average_factor = 0.0
else:
exponential_average_factor = self.momentum
if self.training and self.track_running_stats:
if self.num_batches_tracked is not None:
self.num_batches_tracked += 1
if self.momentum is None:
exponential_average_factor = 1.0 / float(self.num_batches_tracked)
else:
exponential_average_factor = self.momentum
out = F.batch_norm(
input, self.running_mean, self.running_var, None, None,
self.training or not self.track_running_stats,
exponential_average_factor, self.eps)
if self.affine :
if self.single_eps or self.deterministic:
if self.deterministic:
weight = self.weight_mu
bias = self.bias_mu
else:
weight = self.weight_mu + torch.exp(self.weight_log_sigma) * \
torch.randn(self.num_features, device=input.device, dtype=input.dtype)
bias = self.bias_mu + torch.exp(self.bias_log_sigma) * \
torch.randn(self.num_features, device=input.device, dtype=input.dtype)
weight = weight.unsqueeze(0)
bias = bias.unsqueeze(0)
else:
weight = self.weight_mu + torch.exp(self.weight_log_sigma) * \
torch.randn(input.shape[0], self.num_features, device=input.device, dtype=input.dtype)
bias = self.bias_mu + torch.exp(self.bias_log_sigma) * \
torch.randn(input.shape[0], self.num_features, device=input.device, dtype=input.dtype)
if out.dim() == 4:
out = torch.addcmul(bias[:, :, None, None], weight[:, :, None, None], out)
elif out.dim() == 2:
out = torch.addcmul(bias, weight, out)
else:
raise NotImplementedError
return out
def wh_delta2bbox(anchor_points,
shape_wh,
deltas,
means=[0, 0, 0, 0],
stds=[1.0, 1.0, 1.0, 1.0],
max_shape=None,
norm=None,
wh_ratio_clip=16 / 1000):
means = deltas.new_tensor(means).repeat(1, deltas.size(1) // 4)
stds = deltas.new_tensor(stds).repeat(1, deltas.size(1) // 4)
denorm_deltas = deltas * stds + means
dx = denorm_deltas[:, 0::4]
dy = denorm_deltas[:, 1::4]
dw = denorm_deltas[:, 2::4]
dh = denorm_deltas[:, 3::4]
max_ratio = np.abs(np.log(wh_ratio_clip))
dw = dw.clamp(min=-max_ratio, max=max_ratio)
dh = dh.clamp(min=-max_ratio, max=max_ratio)
px = (anchor_points[:, 0]).unsqueeze(1).expand_as(dx)
py = (anchor_points[:, 1]).unsqueeze(1).expand_as(dy)
pw = (shape_wh[:, 0]).unsqueeze(1).expand_as(dw)
ph = (shape_wh[:, 1]).unsqueeze(1).expand_as(dh)
pw = pw.clamp(min=-max_ratio, max=max_ratio)
ph = ph.clamp(min=-max_ratio, max=max_ratio)
pw = norm * pw.exp()
ph = norm * ph.exp()
gw = pw * dw.exp()
gh = ph * dh.exp()
gx = torch.addcmul(px, 1, pw, dx) # gx = px + pw * dx
gy = torch.addcmul(py, 1, ph, dy) # gy = py + ph * dy
x1 = gx - gw * 0.5 + 0.5
y1 = gy - gh * 0.5 + 0.5
x2 = gx + gw * 0.5 - 0.5
y2 = gy + gh * 0.5 - 0.5
if max_shape is not None:
x1 = x1.clamp(min=0, max=max_shape[1] - 1)
y1 = y1.clamp(min=0, max=max_shape[0] - 1)
x2 = x2.clamp(min=0, max=max_shape[1] - 1)
y2 = y2.clamp(min=0, max=max_shape[0] - 1)
bboxes = torch.stack([x1, y1, x2, y2], dim=-1).view_as(deltas)
return bboxes
def backward(self, grad_output):
conv_output, fcn_output = self.saved_tensors
grad_input = None
positive_mask = (grad_output > 0).type_as(grad_output)
grad_input = torch.addcmul(
torch.zeros(conv_output.size()).type_as(conv_output), grad_output,
positive_mask)
return grad_input
def forward(self, outputs, labels):
batch_size = outputs.size(0)
dist_mat = euclidean_distances(outputs)
ID_mat = compute_ID_mat(labels)
pos_dist_mat = Variable(torch.zeros(batch_size, batch_size).to(device))
pos_dist_mat = torch.addcmul(pos_dist_mat, 1, ID_mat, dist_mat)
neg_dist_mat = Variable(torch.zeros(batch_size, batch_size).to(device))
neg_dist_mat = torch.addcmul(neg_dist_mat, 1, 1 - ID_mat, dist_mat)
mask_ = (neg_dist_mat == 0)
neg_dist_mat.masked_fill_(mask_, 10000)
hard_pos = torch.max(pos_dist_mat, dim=0)[0]
hard_neg = torch.min(neg_dist_mat, dim=0)[0]
triplet_losses = torch.clamp(hard_pos - hard_neg + self.margin, min=0)
return torch.sum(triplet_losses) / triplet_losses.size(0)
def forward(self, input1, input2, similarity):
one = torch.as_tensor(np.ones(1) + Global.eps).to(device)
eucl = nn.PairwiseDistance(p=2, eps=1e-6)
input1 = input1.view(1, -1).to(device)
input2 = input2.view(1, -1).to(device)
dist = eucl(input1, input2).double()
sim = torch.div(one, torch.addcmul(one, 1, dist, dist)).float()
similarity = similarity.to(device)
return torch.add(input=F.kl_div(sim, similarity), alpha=self.param, other=F.mse_loss(sim, similarity)).to(device)
def test_local_tensor_tertiary_methods(self):
x = torch.FloatTensor([1, 2, 3])
y = torch.FloatTensor([1, 2, 3])
z = torch.FloatTensor([1, 2, 3])
assert (torch.equal(torch.addcmul(z, 2, x, y), torch.FloatTensor([3., 10., 21.])))
x = torch.FloatTensor([1, 2, 3])
y = torch.FloatTensor([1, 2, 3])
z = torch.FloatTensor([1, 2, 3])
z.addcmul_(2, x, y)
assert (torch.equal(z, torch.FloatTensor([3., 10., 21.])))
x = torch.FloatTensor([[1, 2]])
y = torch.FloatTensor([[1, 2, 3], [4, 5, 6]])
z = torch.FloatTensor([1, 2, 3])
assert(torch.equal(torch.addmm(z, x, y), torch.FloatTensor([[10., 14., 18.]])))
def test_remote_tensor_tertiary_methods(self):
hook = TorchHook(verbose=False)
local = hook.local_worker
remote = VirtualWorker(hook, 1)
local.add_worker(remote)
x = torch.FloatTensor([1, 2, 3]).send(remote)
y = torch.FloatTensor([1, 2, 3]).send(remote)
z = torch.FloatTensor([1, 2, 3]).send(remote)
assert (torch.equal(torch.addcmul(z, 2, x, y).get(), torch.FloatTensor([3., 10., 21.])))
x = torch.FloatTensor([1, 2, 3]).send(remote)
y = torch.FloatTensor([1, 2, 3]).send(remote)
z = torch.FloatTensor([1, 2, 3]).send(remote)
z.addcmul_(2, x, y)
assert (torch.equal(z.get(), torch.FloatTensor([3., 10., 21.])))
x = torch.FloatTensor([[1, 2]]).send(remote)
y = torch.FloatTensor([[1, 2, 3], [4, 5, 6]]).send(remote)
z = torch.FloatTensor([1, 2, 3]).send(remote)
assert (torch.equal(torch.addmm(z, x, y).get(), torch.FloatTensor([[10., 14., 18.]])))
