I can perfectly overfit random samples using your code, so you might want to increase the learning rate to let it converge faster (it still converges with your lr or 1e-4, but takes more epochs):
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

hidden_layers_size = [16, 2]
net = Model(input_size=11, hidden_sizes_fc=hidden_layers_size)
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=1e-3)

data = torch.rand(15, 11)
target = torch.randint(0, 2, (15,))

for epoch in range(1000):
    optimizer.zero_grad()
    output = net(data)
    loss = loss_fn(output, target)
    loss.backward()
    optimizer.step()
    preds = torch.argmax(output, dim=1)
    print('epoch {}, loss {:.3f}, acc {}'.format(
        epoch, loss.item(), (preds==target).float().mean()))