I am trying to understand pytorch by building a basic perceptron with a sigmoid activation and then trying to train it to classify 2 datapoints into either class 0 or 1.

Data:

input features l label

[3,2] l 1

[1,1] l 0

Code:

```
import torch
import torchvision
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
# set random seed
torch.manual_seed(0)
class Perceptron(nn.Module):
def __init__(self):
super(Perceptron,self).__init__()
self.linear = nn.Linear(in_features=2,out_features=1)
def forward(self,x):
x = self.linear(x)
x = torch.sigmoid(x)
return x
class testData(Dataset):
def __init__(self):
super(testData,self).__init__()
test_data = [([3,2],1),([1,1],0)]
self.data = test_data
def __getitem__(self,index):
dp,label = self.data[index]
dp = torch.FloatTensor(dp)
label = torch.tensor(label)
return dp,label
def __len__(self):
return len(self.data)
def main():
model = Perceptron()
dataset = testData()
dataloader = DataLoader(dataset,batch_size=2)
for idx,batch in enumerate(dataloader):
dp,label = batch
print('data',dp)
print('label',label)
preds = model(dp)
print('preds',preds)
loss = F.binary_cross_entropy(preds.float(),label.unsqueeze(1).float())
print('loss',loss)
# loss = F.cross_entropy(preds,label)
# print(loss)
if __name__ == "__main__":
main()
```

Output

```
data tensor([[3., 2.],
[1., 1.]])
label tensor([1, 0])
preds tensor([[0.5401],
[0.4482]], grad_fn=<SigmoidBackward>)
loss tensor(0.6053, grad_fn=<BinaryCrossEntropyBackward>)
```

If I understand the binary cross entropy formula correctly, the output should be:

- ( 1 * log(0.5401) + (1-0) *log(1-0.4482))

And from this previous post, I am using log base e, I get my final answer as 1.21, not the 0.6053 given above. What is being calculated here?