将数据集中在零上并缩放到一的方差有助于解决许多分类问题，但在这种情况下，它会删除我理解的解决问题所需的信息。

另一个可能的问题是损失函数，您在问题中根本没有提到。当你的神经网络只学习两个规则之一时，我会建议一些保持相当高的东西。

好的，我写了一些代码来模拟你的问题。我发现了同样的问题，因此简化了问题。当我修改标签函数以始终选择最大半径而不考虑任意规则时，我发现它仍然无法计算出来，而是会收敛到预测 5 个圆中的每一个的 0.2。看来，如果您不在输入处对圆圈进行排序，则网络无法区分它们。如果您考虑通过密集连接的网络的流量，这是有道理的。如果我们在输入之前尝试对圆圈进行排序，可能会取得一些成功。

import numpy as np
from tqdm import tqdm

N_CIRCLES = 5
CENTRE_RANGE = 1
RMIN, RMAX = 0.1, 0.5
THRESHOLD = 0.45

def label(x):
    # If above threshold, then choose largest circle
    if np.any(x[:5] > THRESHOLD):
        return np.argmax(x[:5])
    
    # Else, choose the circle nearest to (0, 0)
    return np.argmax([np.linalg.norm(x[i:i+2]) for i in range(N_CIRCLES, 3*N_CIRCLES, 2)])

def generate_sample():
    # {r0, r1, r2, r3, r4, x0, y0, x1, y1, x2, y2, x3, y3, x4, y4}
    x = np.concatenate((np.random.uniform(RMIN, RMAX, N_CIRCLES), 
                        np.random.uniform(-CENTRE_RANGE, CENTRE_RANGE, 2*N_CIRCLES)))
    
    return x, label(x)

def generate_samples(n):
    x = np.zeros((n, N_CIRCLES*3))
    y = np.zeros(n)
    
    for i in range(n):
        x[i], y[i] = generate_sample()
    
    return x, y

import torch
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        # Kernel size 5
        self.fc1 = nn.Linear(3*N_CIRCLES, 32)
        self.fc2 = nn.Linear(32, 64)
        self.fc3 = nn.Linear(64, N_CIRCLES)
        
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = F.relu(self.fc3(x))
        return F.softmax(x, dim=1)
    
net = Net()

import torch.optim as optim

optimizer = optim.Adam(net.parameters(), lr=0.001)
loss_function = nn.MSELoss()

BATCH_SIZE = 100
EPOCHS = 1_000

losses = []
for epoch in tqdm(range(EPOCHS)):
    X, y = generate_samples(BATCH_SIZE)
    y = np.array(y, dtype=int)

    ohe = np.zeros((y.size, y.max()+1))
    ohe[np.arange(y.size), y] = 1
    
    X = torch.Tensor(X).view(-1, 3*N_CIRCLES)
    y = torch.Tensor(ohe)

    net.zero_grad()
    yhat = net(X)
    loss = loss_function(yhat, y)
    loss.backward()
    optimizer.step()
    
    losses.append(float(loss.detach().numpy()))    
    
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns 

fig, ax = plt.subplots(figsize=(20, 10))
ax.plot(losses)
plt.show()
```

是的，他们绝对可以“学习”条件规则。

事实证明我在激活函数中有一个错误，我（最终）让这个网络来学习这个问题。它学得非常好，而且很快。令人惊奇的事情，这些神经网络 :) 非常感谢那些回答和评论的人！

是的，通用逼近定理指出，神经网络可以学习中具有一个隐藏层和有限数量的具有非线性激活函数的神经元的任何函数。训练网络可能会出现很多问题，例如，您是否尝试过绘制其性能随时间变化的图表并查看它是否正在收敛？$R^n$