Thanks! The code now looks like this:
class Model(nn.Module):
def __init__(self, input_size, hidden_sizes_fc=[100, 2]):
    super().__init__()
   
    self.fc_list = nn.ModuleList([nn.Linear(input_size, hidden_sizes_fc[0])])
    for hidden_size_fc_ind in range(0, len(hidden_sizes_fc)-1):
        self.fc_list.append(nn.Linear(hidden_sizes_fc[hidden_size_fc_ind],
                                      hidden_sizes_fc[hidden_size_fc_ind+1]))


def forward(self, x):
    relu = nn.ReLU()
    x = self.fc_list[0](x)
    x = relu(x)
    x = self.fc_list[1](x)
    return x

def train_std_nn(net, train, val, epochs, loss_fn):
    optimiser = torch.optim.Adam(net.parameters(), lr=0.0001)
    train_losses_epochs = []
    val_score_epochs = []
    net.train()
    for epoch in trange(epochs):
        train_loss = 0.0
        total_computations = 0
        for X, Y in train:
            output = net(X)
            loss = loss_fn(output, Y)
            optimiser.zero_grad()
            loss.backward()
            optimiser.step()
            train_loss += loss.item()
            total_computations += Y.shape[0]
        train_losses_epochs.append(train_loss / total_computations)
    for X_val, Y_val in val:
        output = net(X_val)
        top_p, top_class = torch.topk(output, 1, dim=1)
        pred = torch.flatten(top_class).detach().numpy()
        val_score_epochs.append(roc_auc_score(Y_val.numpy(), pred))
    return net, train_losses_epochs, val_score_epochs


epochs = 200
batch_size = 4

hidden_layers_size = [16, 2]
net = Model(input_size=11, hidden_sizes_fc=hidden_layers_size).double()
loss_fn = nn.CrossEntropyLoss()

aaa = torch.Tensor(np.random.rand(15, 11)).double()#.type(torch.LongTensor)
bbb = torch.Tensor(np.random.randint(0, 2, (15))).type(torch.LongTensor)

net, train_losses_epochs, val_score_epochs = train_std_nn(net, [[aaa, bbb]], [[aaa, bbb]], epochs, loss_fn)

With e.g. input vector [1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0] after 200 epochs (which I would consider enough to overfitt the data) the predicition is still [1 0 1 1 1 1 1 1 1 1 1 1 1 1 1]. I ran the code a few times and always get very bad predictions.