Dear Community

I would like to build a simple MLP that assigns class A or B to a given input.

The input data are 128d feature representations extracted from FaceNet.

Input data (X): shape=(23445, 128), dtype=float64

The target data are the binary class labels 0 or 1 (denotes class A or B)

Target data (y): shape=(23445, 1), array([0, 0, 1, …, 1, 1, 1]), dtype=int64

```
# Network architecture
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(128, 100)
self.fc2 = nn.Linear(100, 2)
def forward(self, x):
x = x.view(-1, 128)
x = F.relu(self.fc1(x))
x = F.softmax(self.fc2(x))
return x
net = Net()
```

```
# Create 2d array from target data
targets = np.empty((len(y), 2))
for i in range(0, len(y)):
if(y[i] == 0):
targets[i, 0] = 1
targets[i, 1] = 0
else:
targets[i, 0] = 0
targets[i, 1] = 1
```

Result

```
array([[1., 0.],
[1., 0.],
[0., 1.],
...,
[0., 1.],
[0., 1.],
[0., 1.]])
```

```
# Convert inputs, targets to tensor
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
inputs, targets = torch.from_numpy(X), torch.from_numpy(targets)
inputs, targets = inputs.type(torch.FloatTensor),targets.type(torch.FloatTensor)
inputs = inputs.to(device)
targets = targets.to(device)
net.to(device)
net.train()
criterion = nn.BCEWithLogitsLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001)
running_loss = 0.0
# zero the parameter gradients
optimizer.zero_grad()
# forward
# inputs [23445x128]
# outputs [23445x2]
outputs = net(inputs)
```

```
# Result Forward Pass
tensor([[ 0.4894, 0.5106],
[ 0.4900, 0.5100],
[ 0.4897, 0.5103],
...,
[ 0.4813, 0.5187],
[ 0.4825, 0.5175],
[ 0.4889, 0.5111]], device='cuda:0')
```

```
# outputs [23445x2]
# targets [23445x2]
# batch size 23445
loss = criterion(outputs, targets)
print(loss)
loss.backward()
optimizer.step()
```

# Result Loss

`tensor(0.7241, device='cuda:0')`

I hope you have some advice how to approach this problem.

Thank you very much