Yeah, definitely. Thanks a lot for your time. Here it is:

```
import torch
out = torch.tensor([[-0.2422, -0.1971],
[-0.4763, 0.2703],
[-0.5091, 0.1275],
[-0.4697, 0.3374],
[-0.1803, -0.2947],
[-0.6293, 0.1251],
[-0.1562, 0.3778],
[-0.5306, 0.1107],
[-0.3032, 0.4657],
[-0.8656, 0.2032],
[-0.3078, 0.2820],
[-0.4398, 0.1044],
[-0.4838, -0.0568],
[-0.7053, 0.4384],
[-0.4647, -0.0030],
[-0.4993, 0.2855]], device='cuda:0')
labels = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0]
labels = torch.tensor(labels)
with torch.autocast('cuda'):
criterion = torch.nn.BCEWithLogitsLoss(reduce=False)
weight = torch.tensor([0.1, 0.9]) # how to decide on this weights?
weight_ = weight[labels.data.view(-1).long()].view_as(labels)
m = torch.nn.Sigmoid()
print('out[:,1]-out[:,0]: ', out[:,1]-out[:,0])
print('m(out[:,1]-out[:,0]): ', m(out[:,1]-out[:,0]))
#loss = self.criterion(torch.cuda.LongTensor(m(out[:,1]-out[:,0])), labels.cuda())
#loss = criterion(out[:,1]-out[:,0], labels.cuda()) #I think this is wrong with a high probability
loss = criterion(m(out[:,1]-out[:,0]), labels.cuda())
print('loss: ', loss)
print('weight_: ', weight_)
loss_class_weighted = loss * weight_.cuda()
loss_class_weighted = loss_class_weighted.mean()
```

Error/output is:

```
out[:,1]-out[:,0]: tensor([ 0.0451, 0.7466, 0.6366, 0.8071, -0.1144, 0.7544, 0.5340, 0.6413,
0.7689, 1.0688, 0.5898, 0.5442, 0.4270, 1.1437, 0.4617, 0.7848],
device='cuda:0')
m(out[:,1]-out[:,0]): tensor([0.5113, 0.6784, 0.6540, 0.6915, 0.4714, 0.6801, 0.6304, 0.6550, 0.6833,
0.7444, 0.6433, 0.6328, 0.6052, 0.7584, 0.6134, 0.6867],
device='cuda:0')
/home/jalal/research/venv/dpcc/lib/python3.8/site-packages/torch/nn/_reduction.py:42: UserWarning: size_average and reduce args will be deprecated, please use reduction='none' instead.
warnings.warn(warning.format(ret))
---------------------------------------------------------------------------
RuntimeError Traceback (most recent call last)
Input In [16], in <module>
28 print('m(out[:,1]-out[:,0]): ', m(out[:,1]-out[:,0]))
29 #loss = self.criterion(torch.cuda.LongTensor(m(out[:,1]-out[:,0])), labels.cuda())
30 #loss = criterion(out[:,1]-out[:,0], labels.cuda()) #I think this is wrong with a high probability
---> 31 loss = criterion(m(out[:,1]-out[:,0]), torch.FloatTensor.cuda(labels))
33 print('loss: ', loss)
34 print('weight_: ', weight_)
File ~/research/venv/dpcc/lib/python3.8/site-packages/torch/nn/modules/module.py:1102, in Module._call_impl(self, *input, **kwargs)
1098 # If we don't have any hooks, we want to skip the rest of the logic in
1099 # this function, and just call forward.
1100 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
1101 or _global_forward_hooks or _global_forward_pre_hooks):
-> 1102 return forward_call(*input, **kwargs)
1103 # Do not call functions when jit is used
1104 full_backward_hooks, non_full_backward_hooks = [], []
File ~/research/venv/dpcc/lib/python3.8/site-packages/torch/nn/modules/loss.py:704, in BCEWithLogitsLoss.forward(self, input, target)
703 def forward(self, input: Tensor, target: Tensor) -> Tensor:
--> 704 return F.binary_cross_entropy_with_logits(input, target,
705 self.weight,
706 pos_weight=self.pos_weight,
707 reduction=self.reduction)
File ~/research/venv/dpcc/lib/python3.8/site-packages/torch/nn/functional.py:2982, in binary_cross_entropy_with_logits(input, target, weight, size_average, reduce, reduction, pos_weight)
2979 if not (target.size() == input.size()):
2980 raise ValueError("Target size ({}) must be the same as input size ({})".format(target.size(), input.size()))
-> 2982 return torch.binary_cross_entropy_with_logits(input, target, weight, pos_weight, reduction_enum)
RuntimeError: result type Float can't be cast to the desired output type Long
```