def discriminator_loss(logits_real, logits_fake): """ Computes the discriminator loss. You should use the stable torch.nn.functional.binary_cross_entropy_with_logits loss rather than using a separate softmax function followed by the binary cross entropy loss. Inputs: - logits_real: PyTorch Tensor of shape (N,) giving scores for the real data. - logits_fake: PyTorch Tensor of shape (N,) giving scores for the fake data. Returns: - loss: PyTorch Tensor containing (scalar) the loss for the discriminator. """ ones_real = torch.ones_like(logits_real) zeros_fake = torch.zeros_like(logits_fake) D_loss_real = bce_loss(logits_real, ones_real) D_loss_fake = bce_loss(logits_fake, zeros_fake) loss = D_loss_real + D_loss_fake return loss
def discriminator_loss(logits_real, logits_fake): """ Computes the discriminator loss. You should use the stable torch.nn.functional.binary_cross_entropy_with_logits loss rather than using a separate softmax function followed by the binary cross entropy loss. Inputs: - logits_real: PyTorch Tensor of shape (N,) giving scores for the real data. - logits_fake: PyTorch Tensor of shape (N,) giving scores for the fake data. Returns: - loss: PyTorch Tensor containing (scalar) the loss for the discriminator. """ loss = None #################################### # YOUR CODE HERE # #################################### N = logits_real.size() true_labels = Variable(torch.ones(N)).type(dtype) real_image_loss = bce_loss(logits_real, true_labels) fake_image_loss = bce_loss(logits_fake, 1 - true_labels) loss = real_image_loss + fake_image_loss ########## END ########## return loss
def discriminator_loss(logits_real, logits_fake): """ Computes the discriminator loss. You should use the stable torch.nn.functional.binary_cross_entropy_with_logits loss rather than using a separate softmax function followed by the binary cross entropy loss. Inputs: - logits_real: PyTorch Tensor of shape (N,) giving scores for the real data. - logits_fake: PyTorch Tensor of shape (N,) giving scores for the fake data. Returns: - loss: PyTorch Tensor containing (scalar) the loss for the discriminator. """ #################################### # YOUR CODE HERE # #################################### real_loss = bce_loss(logits_real, torch.ones(logits_real.shape).cuda().detach(), reduction='mean') fake_loss = bce_loss(1 - logits_fake, torch.ones(logits_fake.shape).cuda().detach(), reduction='mean') loss = (real_loss + fake_loss) / 2 ########## END ########## return loss
def discriminator_loss(logits_real, logits_fake): """ Computes the discriminator loss. You should use the stable torch.nn.functional.binary_cross_entropy_with_logits loss rather than using a separate softmax function followed by the binary cross entropy loss. Inputs: - logits_real: PyTorch Tensor of shape (N,) giving scores for the real data. - logits_fake: PyTorch Tensor of shape (N,) giving scores for the fake data. Returns: - loss: PyTorch Tensor containing (scalar) the loss for the discriminator. """ loss = None #################################### # YOUR CODE HERE # #################################### labels_real = torch.ones_like(logits_real) labels_fake = torch.zeros_like(logits_fake) loss = bce_loss(logits_real, labels_real, reduction='mean') + bce_loss( logits_fake, labels_fake, reduction='mean') ########## END ########## return loss
def discriminator_loss(logits_real, logits_fake): """ Computes the discriminator loss. You should use the stable torch.nn.functional.binary_cross_entropy_with_logits loss rather than using a separate softmax function followed by the binary cross entropy loss. Inputs: - logits_real: PyTorch Tensor of shape (N,) giving scores for the real data. - logits_fake: PyTorch Tensor of shape (N,) giving scores for the fake data. Returns: - loss: PyTorch Tensor containing (scalar) the loss for the discriminator. """ loss = None #################################### # YOUR CODE HERE # #################################### logits_real_target = torch.ones(logits_real.size(0), 1).cuda() logits_fake_target = torch.zeros(logits_fake.size(0), 1).cuda() real_loss = bce_loss(logits_real.reshape(-1, 1), logits_real_target) fake_loss = bce_loss(logits_fake.reshape(-1, 1), logits_fake_target) loss = real_loss + fake_loss ########## END ########## return loss
def discriminator_loss(logits_real, logits_fake, device): """ Computes the discriminator loss. You should use the stable torch.nn.functional.binary_cross_entropy_with_logits loss rather than using a separate softmax function followed by the binary cross entropy loss. Inputs: - logits_real: PyTorch Tensor of shape (N,) giving scores for the real data. - logits_fake: PyTorch Tensor of shape (N,) giving scores for the fake data. Returns: - loss: PyTorch Tensor containing (scalar) the loss for the discriminator. """ loss = None #################################### # YOUR CODE HERE # #################################### batch_size = logits_fake.size()[0] zeros = torch.zeros((batch_size, 1)).to(device) loss1 = bce_loss(logits_fake, zeros) ones = torch.ones((batch_size, 1)).to(device) loss2 = bce_loss(logits_real, ones) loss = (loss1 + loss2) / batch_size ########## END ########## return loss
def discriminator_loss(logits_real, logits_fake): """ Computes the discriminator loss. You should use the stable torch.nn.functional.binary_cross_entropy_with_logits loss rather than using a separate softmax function followed by the binary cross entropy loss. Inputs: - logits_real: PyTorch Tensor of shape (N,) giving scores for the real data. - logits_fake: PyTorch Tensor of shape (N,) giving scores for the fake data. Returns: - loss: PyTorch Tensor containing (scalar) the loss for the discriminator. """ # Batch size. n = logits_real.size() # Target label vector, the discriminator should be aiming true_labels = Variable(torch.ones(n)).type(dtype) # Discriminator loss has 2 parts: how well it classifies real images and how well it # classifies fake images. real_image_loss = bce_loss(logits_real, true_labels) fake_image_loss = bce_loss(logits_fake, 1 - true_labels) # one-hot labels loss = real_image_loss + fake_image_loss ########## END ########## return loss
def discriminator_loss(logits_real, logits_fake): loss = None N = logits_real.size() true_labels = Variable(torch.ones(N)).type(dtype) real_image_loss = bce_loss(logits_real.cpu(), true_labels) fake_image_loss = bce_loss(logits_fake.cpu(), 1 - true_labels) loss = real_image_loss + fake_image_loss return loss
def generator_loss(logits_fake): """ Computes the generator loss. You should use the stable torch.nn.functional.binary_cross_entropy_with_logits loss rather than using a separate softmax function followed by the binary cross entropy loss. Inputs: - logits_fake: PyTorch Tensor of shape (N,) giving scores for the fake data. Returns: - loss: PyTorch Tensor containing the (scalar) loss for the generator. """ #loss = None # Batch size. n = logits_fake.size() # Generator is trying to make the discriminator output 1 for all its images. # Discriminator determines if the image is real or fake.(1 or 0) # So we create a 'target' label vector of ones for computing generator loss. true_labels = Variable(torch.ones(n)).type(dtype) # Compute the generator loss compraing loss = bce_loss(logits_fake, true_labels) ########## END ########## return loss
def forward(self, v, b, q, labels, bias, hint=None, has_hint=None): """Forward v: [batch, num_objs, obj_dim] b: [batch, num_objs, b_dim] q: [batch_size, seq_length] *_v_emb: [batch, g*v_dim], mask_weight: [batch, g] return: logits, not probs """ w_emb = self.w_emb(q) q_emb = self.q_emb(w_emb) # [batch, q_dim] v_emb, v_att = self.v_att(v, q_emb, hint) # [batch, v_dim] if config.att_norm: v_emb = attention.apply_norm_attention(v, v_att, mode='avg') joint_repr, logits = self.classifier(q_emb, v_emb) debias_loss = torch.zeros(1) if labels is not None: if config.use_debias: debias_loss = self.debias_loss_fn(joint_repr, logits, bias, labels, has_hint) elif config.use_rubi: q_pred = self.extra_c1(q_emb.detach()) q_out = self.extra_c2(q_pred) rubi_logits = logits * torch.sigmoid(q_pred) if has_hint is not None: debias_loss = bce_loss( rubi_logits, labels, reduction='none') + bce_loss( q_out, labels, reduction='none') debias_loss = (debias_loss.sum(dim=1) * has_hint).sum() / has_hint.sum() else: debias_loss = bce_loss(rubi_logits, labels) + bce_loss( q_out, labels) debias_loss *= labels.size(1) return logits, debias_loss, v_att
def generator_loss(logits_fake): """ Computes the generator loss. You should use the stable torch.nn.functional.binary_cross_entropy_with_logits loss rather than using a separate softmax function followed by the binary cross entropy loss. Inputs: - logits_fake: PyTorch Tensor of shape (N,) giving scores for the fake data. Returns: - loss: PyTorch Tensor containing the (scalar) loss for the generator. """ ones = torch.ones_like(logits_fake) loss = bce_loss(logits_fake, ones) return loss
def generator_loss(logits_fake): loss = None N = logits_fake.size() true_labels = Variable(torch.ones(N)).type(dtype) loss = bce_loss(logits_fake.cpu(), true_labels) return loss
def compute_loss(outputs, y, mask): masked_loss = bce_loss( outputs, y.float(), reduction='none') * mask.float() # (batch_size, max_len) return masked_loss.sum() / mask.sum()