def loss(self, proposal_classes: Tensor, proposal_transformers: Tensor,
gt_proposal_classes: Tensor, gt_proposal_transformers: Tensor,
batch_size, batch_indices) -> Tuple[Tensor, Tensor]:
proposal_transformers = proposal_transformers.view(-1, self.num_classes, 4)[torch.arange(end=len(proposal_transformers), dtype=torch.long), gt_proposal_classes]
transformer_normalize_mean = self._transformer_normalize_mean.to(device=gt_proposal_transformers.device)
transformer_normalize_std = self._transformer_normalize_std.to(device=gt_proposal_transformers.device)
gt_proposal_transformers = (gt_proposal_transformers - transformer_normalize_mean) / transformer_normalize_std # scale up target to make regressor easier to learn
cross_entropies = torch.empty(batch_size, dtype=torch.float, device=proposal_classes.device)
smooth_l1_losses = torch.empty(batch_size, dtype=torch.float, device=proposal_transformers.device)
for batch_index in range(batch_size):
selected_indices = (batch_indices == batch_index).nonzero().view(-1)
cross_entropy = F.cross_entropy(input=proposal_classes[selected_indices],
target=gt_proposal_classes[selected_indices])
fg_indices = gt_proposal_classes[selected_indices].nonzero().view(-1)
smooth_l1_loss = beta_smooth_l1_loss(input=proposal_transformers[selected_indices][fg_indices],
target=gt_proposal_transformers[selected_indices][fg_indices],
beta=self._proposal_smooth_l1_loss_beta)
cross_entropies[batch_index] = cross_entropy
smooth_l1_losses[batch_index] = smooth_l1_loss
return cross_entropies, smooth_l1_losses
def loss(self, anchor_objectnesses: Tensor, anchor_transformers: Tensor,
gt_anchor_objectnesses: Tensor, gt_anchor_transformers: Tensor,
batch_size: int, batch_indices: Tensor) -> Tuple[Tensor, Tensor]:
cross_entropies = torch.empty(batch_size,
dtype=torch.float,
device=anchor_objectnesses.device)
smooth_l1_losses = torch.empty(batch_size,
dtype=torch.float,
device=anchor_transformers.device)
for batch_index in range(batch_size):
selected_indices = (
batch_indices == batch_index).nonzero().view(-1)
cross_entropy = F.cross_entropy(
input=anchor_objectnesses[selected_indices],
target=gt_anchor_objectnesses[selected_indices])
fg_indices = gt_anchor_objectnesses[selected_indices].nonzero(
).view(-1)
smooth_l1_loss = beta_smooth_l1_loss(
input=anchor_transformers[selected_indices][fg_indices],
target=gt_anchor_transformers[selected_indices][fg_indices],
beta=self._anchor_smooth_l1_loss_beta)
cross_entropies[batch_index] = cross_entropy
smooth_l1_losses[batch_index] = smooth_l1_loss
return cross_entropies, smooth_l1_losses
def loss(self, proposal_classes: Tensor, proposal_transformers: Tensor,
gt_proposal_classes: Tensor, gt_proposal_transformers: Tensor,
batch_size, batch_indices) -> Tuple[Tensor, Tensor]:
# proposal_classes@(bn*128,num_cls)
# proposal_transformers@(bn*128,4*num_cls)
# gt_proposal_classes@(128,)
# gt_proposal_transformers@(bn*128,4*num_cls)
# batch_size 通常为1，因此batch_indices就是1*128个0
#由于proposal_transformers对于所有num_cls都生成了4个变换，总计有4*num_cls个预测变换，这里要根据 gt_proposal_classes 只选择有label的预测变换，因此：
#proposal_transformers：(bn*128,84)-->(bn*128,4)
proposal_transformers = proposal_transformers.view(
-1, self.num_classes, 4
)[torch.arange(end=len(proposal_transformers), dtype=torch.long),
gt_proposal_classes]
#对 gt_proposal_transformers 进行正则化处理
transformer_normalize_mean = self._transformer_normalize_mean.to(
device=gt_proposal_transformers.device)
transformer_normalize_std = self._transformer_normalize_std.to(
device=gt_proposal_transformers.device)
gt_proposal_transformers = (
gt_proposal_transformers - transformer_normalize_mean
) / transformer_normalize_std # scale up target to make regressor easier to learn
cross_entropies = torch.empty(batch_size,
dtype=torch.float,
device=proposal_classes.device)
smooth_l1_losses = torch.empty(batch_size,
dtype=torch.float,
device=proposal_transformers.device)
for batch_index in range(batch_size):
#batch_indices@(bn*128)
#由于bn常取1,因此下面的selected_indices相当于选择整个批
selected_indices = (
batch_indices == batch_index).nonzero().view(-1)
#1.使用交叉熵计算pc和gpc之间的损失
cross_entropy = F.cross_entropy(
input=proposal_classes[selected_indices],
target=gt_proposal_classes[selected_indices])
#2.使用smooth_l1计算前景pt和gpt之间的损失
fg_indices = gt_proposal_classes[selected_indices].nonzero(
).view(-1)
smooth_l1_loss = beta_smooth_l1_loss(
input=proposal_transformers[selected_indices][fg_indices],
target=gt_proposal_transformers[selected_indices]
[fg_indices],
beta=self._proposal_smooth_l1_loss_beta)
cross_entropies[batch_index] = cross_entropy
smooth_l1_losses[batch_index] = smooth_l1_loss
return cross_entropies, smooth_l1_losses
def loss(self, proposal_classes, proposal_transformers,
gt_proposal_classes, gt_proposal_transformers, batch_size,
batch_indices):
'''
Only take the loss from the correct class from the bounding box regressor
scale up target to make regressor easier to learn
'''
proposal_transformers = proposal_transformers.view(
-1, self.num_classes,
4)[torch.arange(len(proposal_transformers)),
gt_proposal_classes]
transformer_normalize_mean = self._transformer_normalize_mean.to(
device=gt_proposal_transformers.device)
transformer_normalize_std = self._transformer_normalize_std.to(
device=gt_proposal_transformers.device)
gt_proposal_transformers = (
gt_proposal_transformers -
transformer_normalize_mean) / transformer_normalize_std
cross_entropies = torch.empty(batch_size,
dtype=torch.float,
device=proposal_classes.device)
smooth_l1_losses = torch.empty(batch_size,
dtype=torch.float,
device=proposal_transformers.device)
for batch_index in range(batch_size):
selected_indices = (
batch_indices == batch_index).nonzero().view(-1)
cross_entropy = F.cross_entropy(
input=proposal_classes[selected_indices],
target=gt_proposal_classes[selected_indices])
# print(selected_indices)
# print(gt_proposal_classes)
fg_indices = gt_proposal_classes[selected_indices].nonzero(
).view(-1)
# print('fg_indices',fg_indices)
# with torch.no_grad():
smooth_l1_loss_ = beta_smooth_l1_loss(
input=proposal_transformers[selected_indices][fg_indices],
target=gt_proposal_transformers[selected_indices]
[fg_indices],
beta=self._proposal_smooth_l1_loss_beta)
#print(smooth_l1_loss_custom)
#print(proposal_transformers[selected_indices][fg_indices])
#print(gt_proposal_transformers[selected_indices][fg_indices])
#smooth_l1_loss_ = smooth_l1_loss(input=proposal_transformers[selected_indices][fg_indices],target=gt_proposal_transformers[selected_indices][fg_indices])
#print(smooth_l1_loss_)
cross_entropies[batch_index] = cross_entropy
smooth_l1_losses[batch_index] = smooth_l1_loss_
return cross_entropies, smooth_l1_losses
def loss(self, anchor_objectnesses: Tensor, anchor_transformers: Tensor,
gt_anchor_objectnesses: Tensor, gt_anchor_transformers: Tensor,
batch_size: int, batch_indices: Tensor) -> Tuple[Tensor, Tensor]:
cross_entropies = torch.empty(batch_size,
dtype=torch.float,
device=anchor_objectnesses.device)
smooth_l1_losses = torch.empty(batch_size,
dtype=torch.float,
device=anchor_transformers.device)
for batch_index in range(batch_size):
#一批一批计算误差.
#这里因为通常batch_size==1，所以batch_indices总是等与batch_index.相当于对于这唯一的一批是个全选的效果.
selected_indices = (batch_indices == batch_index).nonzero().view(
-1) #(256,).
#1.使用交叉熵函数计算ao与gao之间损失
#因为后景对应的label是0，前景对应的label是1，所以ao的第一列(除去batch内索引列)是后景，第二列是前景.
cross_entropy = F.cross_entropy(
input=anchor_objectnesses[selected_indices],
target=gt_anchor_objectnesses[selected_indices])
#对于transformer只计算前景:由nonzero计算出前景的索引
#2.使用smooth_l1函数计算前景变换at与gat之间的损失
fg_indices = gt_anchor_objectnesses[selected_indices].nonzero(
).view(-1) #(fg_n,)
smooth_l1_loss = beta_smooth_l1_loss(
input=anchor_transformers[selected_indices][fg_indices],
target=gt_anchor_transformers[selected_indices][fg_indices],
beta=self._anchor_smooth_l1_loss_beta)
cross_entropies[batch_index] = cross_entropy
smooth_l1_losses[batch_index] = smooth_l1_loss
return cross_entropies, smooth_l1_losses
